[analyzer] Don't display implementation checkers under -analyzer-checker-help, but do under the new flag -analyzer-checker-help-hidden

[Szelethus]

Summary

During my work on analyzer dependencies, I created a great amount of new checkers that emitted no diagnostics at all, and were purely modeling some function or another.

However, the user shouldn't really disable/enable these by hand, so I think it would be great to hide them by default, along with other, older modeling-only checkers and debug checkers. I intentionally chose not to hide alpha checkers, because they have a scary enough name, in my opinion, to cause no surprise when they emit false positives or cause crashes.

CodeChecker also works by individually enabling and disabling each and every checker, and the dependency patches would create a great amount of unnecessary work on that side. But this is yet another reason, not the main motivation behind this patch :)

The patch introduces the Hidden bit into the TableGen files (you may remember it before I removed it in D53995), and checkers that are either marked as hidden, or are in a package that is marked hidden won't be displayed under -analyzer-checker-help. -analyzer-checker-help-hidden, a new flag meant for developers only, displays the full list.

Some dumps I made while coding (not a part of this patch):

CHECKER HIDDEN: debug.AnalysisOrder
CHECKER HIDDEN: debug.Stats
CHECKER NOT HIDDEN: alpha.security.ArrayBound
CHECKER NOT HIDDEN: alpha.security.ArrayBoundV2
CHECKER NOT HIDDEN: osx.cocoa.AutoreleaseWrite
CHECKER NOT HIDDEN: alpha.unix.BlockInCriticalSection
CHECKER NOT HIDDEN: alpha.core.BoolAssignment
CHECKER HIDDEN: core.builtin.BuiltinFunctions
CHECKER NOT HIDDEN: osx.coreFoundation.CFError
CHECKER HIDDEN: debug.DumpCFG
CHECKER HIDDEN: debug.ViewCFG
CHECKER NOT HIDDEN: osx.coreFoundation.CFNumber
CHECKER NOT HIDDEN: osx.coreFoundation.CFRetainRelease
CHECKER NOT HIDDEN: alpha.unix.cstring.BufferOverlap
CHECKER HIDDEN: unix.cstring.CStringModeling
CHECKER NOT HIDDEN: alpha.unix.cstring.NotNullTerminated
CHECKER NOT HIDDEN: unix.cstring.NullArg
CHECKER NOT HIDDEN: alpha.unix.cstring.OutOfBounds
CHECKER NOT HIDDEN: unix.cstring.BadSizeArg
CHECKER HIDDEN: cplusplus.SelfAssignment
CHECKER NOT HIDDEN: core.CallAndMessage
CHECKER NOT HIDDEN: alpha.core.CallAndMessageUnInitRefArg
CHECKER HIDDEN: debug.DumpCalls
CHECKER HIDDEN: debug.DumpCallGraph
CHECKER HIDDEN: debug.ViewCallGraph
CHECKER NOT HIDDEN: alpha.core.CastSize
CHECKER NOT HIDDEN: alpha.core.CastToStruct
CHECKER NOT HIDDEN: alpha.unix.Chroot
CHECKER NOT HIDDEN: osx.cocoa.ClassRelease
CHECKER NOT HIDDEN: alpha.clone.CloneChecker
CHECKER HIDDEN: debug.ConfigDumper
CHECKER NOT HIDDEN: alpha.core.Conversion
CHECKER NOT HIDDEN: valist.CopyToSelf
CHECKER NOT HIDDEN: deadcode.DeadStores
CHECKER NOT HIDDEN: alpha.cplusplus.DeleteWithNonVirtualDtor
CHECKER NOT HIDDEN: security.insecureAPI.DeprecatedOrUnsafeBufferHandling
CHECKER NOT HIDDEN: core.NullDereference
CHECKER NOT HIDDEN: alpha.osx.cocoa.DirectIvarAssignment
CHECKER NOT HIDDEN: alpha.osx.cocoa.DirectIvarAssignmentForAnnotatedFunctions
CHECKER NOT HIDDEN: core.DivideZero
CHECKER HIDDEN: debug.DumpDominators
CHECKER HIDDEN: unix.DynamicMemoryModeling
CHECKER NOT HIDDEN: alpha.core.DynamicTypeChecker
CHECKER NOT HIDDEN: core.DynamicTypePropagation
CHECKER NOT HIDDEN: optin.osx.cocoa.localizability.EmptyLocalizationContextChecker
CHECKER NOT HIDDEN: alpha.cplusplus.EnumCastOutOfRange
CHECKER HIDDEN: debug.ViewExplodedGraph
CHECKER HIDDEN: debug.ExprInspection
CHECKER NOT HIDDEN: alpha.core.FixedAddr
CHECKER NOT HIDDEN: security.FloatLoopCounter
CHECKER NOT HIDDEN: optin.performance.GCDAntipattern
CHECKER HIDDEN: apiModeling.google.GTest
CHECKER NOT HIDDEN: alpha.security.taint.TaintPropagation
CHECKER NOT HIDDEN: alpha.core.IdenticalExpr
CHECKER NOT HIDDEN: cplusplus.InnerPointer
CHECKER NOT HIDDEN: alpha.osx.cocoa.InstanceVariableInvalidation
CHECKER NOT HIDDEN: alpha.cplusplus.InvalidatedIterator
CHECKER HIDDEN: alpha.cplusplus.IteratorModeling
CHECKER NOT HIDDEN: alpha.cplusplus.IteratorRange
CHECKER HIDDEN: alpha.osx.cocoa.IvarInvalidationModeling
CHECKER NOT HIDDEN: alpha.llvm.Conventions
CHECKER HIDDEN: debug.DumpLiveStmts
CHECKER HIDDEN: debug.DumpLiveVars
CHECKER NOT HIDDEN: osx.MIG
CHECKER NOT HIDDEN: optin.mpi.MPI-Checker
CHECKER NOT HIDDEN: osx.SecKeychainAPI
CHECKER NOT HIDDEN: osx.API
CHECKER NOT HIDDEN: unix.Malloc
CHECKER NOT HIDDEN: alpha.security.MallocOverflow
CHECKER NOT HIDDEN: unix.MallocSizeof
CHECKER NOT HIDDEN: unix.MismatchedDeallocator
CHECKER NOT HIDDEN: alpha.cplusplus.MismatchedIterator
CHECKER NOT HIDDEN: alpha.osx.cocoa.MissingInvalidationMethod
CHECKER NOT HIDDEN: alpha.security.MmapWriteExec
CHECKER NOT HIDDEN: cplusplus.Move
CHECKER NOT HIDDEN: osx.cocoa.NSAutoreleasePool
CHECKER NOT HIDDEN: osx.cocoa.NSError
CHECKER HIDDEN: osx.NSOrCFErrorDerefChecker
CHECKER NOT HIDDEN: cplusplus.NewDelete
CHECKER NOT HIDDEN: cplusplus.NewDeleteLeaks
CHECKER NOT HIDDEN: osx.cocoa.NilArg
CHECKER HIDDEN: core.builtin.NoReturnFunctions
CHECKER NOT HIDDEN: optin.osx.cocoa.localizability.NonLocalizedStringChecker
CHECKER NOT HIDDEN: core.NonNullParamChecker
CHECKER HIDDEN: core.NonnilStringConstants
CHECKER NOT HIDDEN: nullability.NullPassedToNonnull
CHECKER NOT HIDDEN: nullability.NullReturnedFromNonnull
CHECKER HIDDEN: nullability.NullabilityBase
CHECKER NOT HIDDEN: nullability.NullableDereferenced
CHECKER NOT HIDDEN: nullability.NullablePassedToNonnull
CHECKER NOT HIDDEN: nullability.NullableReturnedFromNonnull
CHECKER NOT HIDDEN: osx.NumberObjectConversion
CHECKER NOT HIDDEN: optin.osx.OSObjectCStyleCast
CHECKER NOT HIDDEN: osx.OSObjectRetainCount
CHECKER NOT HIDDEN: osx.cocoa.AtSync
CHECKER NOT HIDDEN: osx.coreFoundation.containers.PointerSizedValues
CHECKER NOT HIDDEN: osx.coreFoundation.containers.OutOfBounds
CHECKER NOT HIDDEN: osx.cocoa.Dealloc
CHECKER NOT HIDDEN: osx.cocoa.ObjCGenerics
CHECKER NOT HIDDEN: osx.cocoa.Loops
CHECKER NOT HIDDEN: osx.cocoa.IncompatibleMethodTypes
CHECKER NOT HIDDEN: osx.cocoa.NonNilReturnValue
CHECKER NOT HIDDEN: osx.ObjCProperty
CHECKER NOT HIDDEN: osx.cocoa.SelfInit
CHECKER NOT HIDDEN: osx.cocoa.MissingSuperCall
CHECKER NOT HIDDEN: osx.cocoa.SuperDealloc
CHECKER NOT HIDDEN: osx.cocoa.UnusedIvars
CHECKER NOT HIDDEN: optin.performance.Padding
CHECKER NOT HIDDEN: alpha.osx.cocoa.localizability.PluralMisuseChecker
CHECKER NOT HIDDEN: alpha.core.PointerArithm
CHECKER NOT HIDDEN: alpha.nondeterminism.PointerSorting
CHECKER NOT HIDDEN: alpha.core.PointerSub
CHECKER NOT HIDDEN: alpha.unix.PthreadLock
CHECKER HIDDEN: debug.ReportStmts
CHECKER HIDDEN: osx.cocoa.RetainCountBase
CHECKER NOT HIDDEN: osx.cocoa.RetainCount
CHECKER NOT HIDDEN: alpha.security.ReturnPtrRange
CHECKER NOT HIDDEN: core.uninitialized.UndefReturn
CHECKER NOT HIDDEN: osx.cocoa.RunLoopAutoreleaseLeak
CHECKER HIDDEN: security.insecureAPI.SecuritySyntaxChecker
CHECKER NOT HIDDEN: alpha.unix.SimpleStream
CHECKER NOT HIDDEN: alpha.core.SizeofPtr
CHECKER NOT HIDDEN: alpha.core.StackAddressAsyncEscape
CHECKER HIDDEN: core.StackAddrEscapeBase
CHECKER NOT HIDDEN: core.StackAddressEscape
CHECKER HIDDEN: apiModeling.StdCLibraryFunctions
CHECKER NOT HIDDEN: alpha.unix.Stream
CHECKER HIDDEN: debug.TaintTest
CHECKER NOT HIDDEN: alpha.core.TestAfterDivZero
CHECKER HIDDEN: debug.DumpTraversal
CHECKER HIDDEN: apiModeling.TrustNonnull
CHECKER NOT HIDDEN: security.insecureAPI.UncheckedReturn
CHECKER NOT HIDDEN: core.uninitialized.Branch
CHECKER NOT HIDDEN: core.uninitialized.CapturedBlockVariable
CHECKER NOT HIDDEN: core.UndefinedBinaryOperatorResult
CHECKER NOT HIDDEN: core.uninitialized.ArraySubscript
CHECKER NOT HIDDEN: core.uninitialized.Assign
CHECKER NOT HIDDEN: valist.Uninitialized
CHECKER NOT HIDDEN: alpha.cplusplus.UninitializedObject
CHECKER NOT HIDDEN: unix.API
CHECKER NOT HIDDEN: optin.portability.UnixAPI
CHECKER NOT HIDDEN: alpha.deadcode.UnreachableCode
CHECKER NOT HIDDEN: valist.Unterminated
CHECKER NOT HIDDEN: core.VLASize
CHECKER HIDDEN: valist.ValistBase
CHECKER NOT HIDDEN: osx.cocoa.VariadicMethodTypes
CHECKER NOT HIDDEN: unix.Vfork
CHECKER NOT HIDDEN: optin.cplusplus.VirtualCall
CHECKER NOT HIDDEN: security.insecureAPI.bcmp
CHECKER NOT HIDDEN: security.insecureAPI.bcopy
CHECKER NOT HIDDEN: security.insecureAPI.bzero
CHECKER NOT HIDDEN: security.insecureAPI.getpw
CHECKER NOT HIDDEN: security.insecureAPI.gets
CHECKER NOT HIDDEN: security.insecureAPI.mkstemp
CHECKER NOT HIDDEN: security.insecureAPI.mktemp
CHECKER NOT HIDDEN: security.insecureAPI.rand
CHECKER NOT HIDDEN: security.insecureAPI.strcpy
CHECKER NOT HIDDEN: security.insecureAPI.vfork

[NoQ]

Yup, that sounds useful!

I intentionally chose not to hide alpha checkers, because they have a scary enough name, in my opinion, to cause no surprise when they emit false positives or cause crashes.

I've seen people yelling really loudly, like "look, your clang is crap, it crashes all over the place", after enabling all alpha checkers at once. It's fairly hard to explain to the wider audience that LLVM doesn't have feature branches, so we have to put all unfinished features into the released product with a kind notice of "please don't use them, they're not ready yet". Our development policy is fairly unusual in this regard. It's like selling a washing machine with 30 extra buttons and by pressing any of them you get a slight chance that it washes a bit better and also a slight chance that it explodes and covers your house with white soapy goop and pieces of underwear, and all it says about these buttons is that they're "alpha".

[Szelethus]

I plan to do the same for non-checker and checker options too.

I'll leave this up for just a little while to give people time to object.

[Szelethus]

Hide security.insecureAPI.SecuritySyntaxChecker by default.

[o.gyorgy]

Great, at least the users will not enable the debug checkers by accident!
We will check on the CodeChecker side if any configuration needs to be updated.

LGTM

[Szelethus]

In D60925#1489034, @o.gyorgy wrote:

Great, at least the users will not enable the debug checkers by accident!
We will check on the CodeChecker side if any configuration needs to be updated.

LGTM

I committed after checking whether this works with CodeChecker. I listed the enabled-by-default list with CodeChecker checkers --only-enabled, and made sure that the list didn't change after this patch. I also made sure that CodeChecker checkers --only-enabled is consistent with clang [blahblah] -analyzer-list-enabled-checkers, meaning that what CodeChecker requested was actually enabled, and nothing else (except modeling checkers, of course).

I guess adding a strictly developer only option to list the hidden checkers as well might be desirable, if we need to disable certain modeling checkers to get rid of some crashes.

cfe/trunk/include/clang/Driver/CC1Options.td

 def analyzer_stats : Flag<["-"], "analyzer-stats">,
   HelpText<"Print internal analyzer statistics.">;
 
 def analyzer_checker : Separate<["-"], "analyzer-checker">,
   HelpText<"Choose analyzer checkers to enable">,
   ValuesCode<[{
     const char *Values =
     #define GET_CHECKERS
-    #define CHECKER(FULLNAME, CLASS, HT, DOC_URI)  FULLNAME ","
+    #define CHECKER(FULLNAME, CLASS, HT, DOC_URI, IS_HIDDEN)  FULLNAME ","
     #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
     #undef GET_CHECKERS
     #define GET_PACKAGES
     #define PACKAGE(FULLNAME)  FULLNAME ","
     #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
     #undef GET_PACKAGES
     ;
   }]>;
 def analyzer_checker_EQ : Joined<["-"], "analyzer-checker=">,
   Alias<analyzer_checker>;
 
 def analyzer_disable_checker : Separate<["-"], "analyzer-disable-checker">,
   HelpText<"Choose analyzer checkers to disable">;
 def analyzer_disable_checker_EQ : Joined<["-"], "analyzer-disable-checker=">,
   Alias<analyzer_disable_checker>;
 
 def analyzer_disable_all_checks : Flag<["-"], "analyzer-disable-all-checks">,
   HelpText<"Disable all static analyzer checks">;
 
 def analyzer_checker_help : Flag<["-"], "analyzer-checker-help">,
   HelpText<"Display the list of analyzer checkers that are available">;
 
+def analyzer_checker_help_hidden : Flag<["-"], "analyzer-checker-help-hidden">,
+  HelpText<"Display the list of analyzer checkers that are available, "
+           "including modeling checkers">;
+
 def analyzer_config_help : Flag<["-"], "analyzer-config-help">,
   HelpText<"Display the list of -analyzer-config options">;
 
 def analyzer_list_enabled_checkers : Flag<["-"], "analyzer-list-enabled-checkers">,
   HelpText<"Display the list of enabled analyzer checkers">;
 
 def analyzer_config : Separate<["-"], "analyzer-config">,
   HelpText<"Choose analyzer options to enable">;

cfe/trunk/include/clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h

 class LangOptions;
 
 namespace ento {
 
 class CheckerManager;
 class CheckerRegistry;
 
 #define GET_CHECKERS
-#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI)                            \
+#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
   void register##CLASS(CheckerManager &mgr);                                   \
   bool shouldRegister##CLASS(const LangOptions &LO);
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER
 #undef GET_CHECKERS
 
 } // end ento namespace
 
 } // end clang namespace
 
 #endif

cfe/trunk/include/clang/StaticAnalyzer/Checkers/CheckerBase.td

 /// 'core.NullDereference'.
 /// Example:
 ///   def Core : Package<"core">;
 class Package<string name> {
   string              PackageName = name;
   // This field is optional.
   list<CmdLineOption> PackageOptions;
   Package             ParentPackage;
+  bit                 Hidden = 0;
 }
 
 /// Describes a 'super' package that holds another package inside it. This is
 /// used to nest packages in one another. One may, for example, create the
 /// 'builtin' package inside 'core', thus creating the package 'core.builtin'.
 /// Example:
 ///   def CoreBuiltin : Package<"builtin">, ParentPackage<Core>;
 class ParentPackage<Package P> { Package ParentPackage = P; }
class Checker<string name = ""> {
   string              CheckerName = name;
   string              HelpText;
   // This field is optional.
   list<CmdLineOption> CheckerOptions;
   // This field is optional.
   list<Checker>       Dependencies;
   bits<2>             Documentation;
   Package             ParentPackage;
+  bit                 Hidden = 0;
 }
 
 /// Describes a list of checker options.
 class CheckerOptions<list<CmdLineOption> opts> {
   list<CmdLineOption> CheckerOptions = opts;
 }
 
 /// Describes dependencies in between checkers. For example, InnerPointerChecker
 /// relies on information MallocBase gathers.
 /// Example:
 ///   def InnerPointerChecker : Checker<"InnerPointer">,
 ///     HelpText<"Check for inner pointers of C++ containers used after "
 ///              "re/deallocation">,
 ///     Dependencies<[MallocBase]>;
 class Dependencies<list<Checker> Deps = []> {
   list<Checker> Dependencies = Deps;
 }
+
+/// Marks a checker or a package hidden. Hidden entries won't be displayed in
+/// -analyzer-checker-help, which is desirable for alpha or modeling checkers.
+class Hidden { bit Hidden = 1; }

cfe/trunk/include/clang/StaticAnalyzer/Checkers/Checkers.td

 // 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">;
-def CoreBuiltin : Package<"builtin">, ParentPackage<Core>;
+def CoreBuiltin : Package<"builtin">, ParentPackage<Core>, Hidden;
 def CoreUninitialized  : Package<"uninitialized">, ParentPackage<Core>;
 def CoreAlpha : Package<"core">, ParentPackage<Alpha>;
 
 // The OptIn package is for checkers that are not alpha and that would normally
 // be on by default but where the driver does not have enough information to
 // determine when they are applicable. For example, localizability checkers fit
 // this criterion because the driver cannot determine whether a project is
 // localized or not -- this is best determined at the IDE or build-system level.

 def MPI : Package<"mpi">, ParentPackage<OptIn>;
 
 def LLVM : Package<"llvm">;
 def LLVMAlpha : Package<"llvm">, ParentPackage<Alpha>;
 
 // The APIModeling package is for checkers that model APIs and don't perform
 // any diagnostics. These checkers are always turned on; this package is
 // intended for API modeling that is not controlled by the target triple.
-def APIModeling : Package<"apiModeling">;
-def GoogleAPIModeling : Package<"google">, ParentPackage<APIModeling>;
+def APIModeling : Package<"apiModeling">, Hidden;
+def GoogleAPIModeling : Package<"google">, ParentPackage<APIModeling>, Hidden;
 
-def Debug : Package<"debug">;
+def Debug : Package<"debug">, Hidden;
 
 def CloneDetectionAlpha : Package<"clone">, ParentPackage<Alpha>;
 
 def NonDeterminismAlpha : Package<"nondeterminism">, ParentPackage<Alpha>;
 
 //===----------------------------------------------------------------------===//
 // Core Checkers.
 //===----------------------------------------------------------------------===//
def DivZeroChecker : Checker<"DivideZero">,
   Documentation<HasDocumentation>;
 
 def UndefResultChecker : Checker<"UndefinedBinaryOperatorResult">,
   HelpText<"Check for undefined results of binary operators">,
   Documentation<HasDocumentation>;
 
 def StackAddrEscapeBase : Checker<"StackAddrEscapeBase">,
   HelpText<"Generate information about stack address escapes.">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def StackAddrEscapeChecker : Checker<"StackAddressEscape">,
   HelpText<"Check that addresses to stack memory do not escape the function">,
   Dependencies<[StackAddrEscapeBase]>,
   Documentation<HasDocumentation>;
 
 def DynamicTypePropagation : Checker<"DynamicTypePropagation">,
   HelpText<"Generate dynamic type information">,
   Documentation<NotDocumented>;
 
 def NonnullGlobalConstantsChecker: Checker<"NonnilStringConstants">,
   HelpText<"Assume that const string-like globals are non-null">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 } // end "core"
 
 let ParentPackage = CoreAlpha in {
 
 def BoolAssignmentChecker : Checker<"BoolAssignment">,
   HelpText<"Warn about assigning non-{0,1} values to Boolean variables">,
   Documentation<HasAlphaDocumentation>;

 //===----------------------------------------------------------------------===//
 // Nullability checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = Nullability in {
 
 def NullabilityBase : Checker<"NullabilityBase">,
   HelpText<"Stores information during the analysis about nullability.">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def NullPassedToNonnullChecker : Checker<"NullPassedToNonnull">,
   HelpText<"Warns when a null pointer is passed to a pointer which has a "
            "_Nonnull type.">,
   Dependencies<[NullabilityBase]>,
   Documentation<HasDocumentation>;
 
 def NullReturnedFromNonnullChecker : Checker<"NullReturnedFromNonnull">,

 //===----------------------------------------------------------------------===//
 
 let ParentPackage = CString in {
 
 def CStringModeling : Checker<"CStringModeling">,
   HelpText<"The base of several CString related checkers. On it's own it emits "
            "no reports, but adds valuable information to the analysis when "
            "enabled.">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def CStringNullArg : Checker<"NullArg">,
   HelpText<"Check for null pointers being passed as arguments to C string "
            "functions">,
   Dependencies<[CStringModeling]>,
   Documentation<HasDocumentation>;
 
 def CStringSyntaxChecker : Checker<"BadSizeArg">,
CheckerOptions<[
     CmdLineOption<Boolean,
                   "Optimistic",
                   "If set to true, the checker assumes that all the "
                   "allocating and deallocating functions are annotated with "
                   "ownership_holds, ownership_takes and ownership_returns.",
                   "false">
   ]>,
   Dependencies<[CStringModeling]>,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def MallocChecker: Checker<"Malloc">,
   HelpText<"Check for memory leaks, double free, and use-after-free problems. "
            "Traces memory managed by malloc()/free().">,
   Dependencies<[DynamicMemoryModeling]>,
   Documentation<HasDocumentation>;
 
 def MallocSizeofChecker : Checker<"MallocSizeof">,

 
 def NewDeleteLeaksChecker : Checker<"NewDeleteLeaks">,
   HelpText<"Check for memory leaks. Traces memory managed by new/delete.">,
   Dependencies<[NewDeleteChecker]>,
   Documentation<HasDocumentation>;
 
 def CXXSelfAssignmentChecker : Checker<"SelfAssignment">,
   HelpText<"Checks C++ copy and move assignment operators for self assignment">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def SmartPtrModeling: Checker<"SmartPtr">,
   HelpText<"Model behavior of C++ smart pointers">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def MoveChecker: Checker<"Move">,
   HelpText<"Find use-after-move bugs in C++">,
   CheckerOptions<[
     CmdLineOption<String,
                   "WarnOn",
                   "In non-aggressive mode, only warn on use-after-move of "
                   "local variables (or local rvalue references) and of STL "
def DeleteWithNonVirtualDtorChecker : Checker<"DeleteWithNonVirtualDtor">,
   Documentation<HasAlphaDocumentation>;
 
 def EnumCastOutOfRangeChecker : Checker<"EnumCastOutOfRange">,
   HelpText<"Check integer to enumeration casts for out of range values">,
   Documentation<HasAlphaDocumentation>;
 
 def IteratorModeling : Checker<"IteratorModeling">,
   HelpText<"Models iterators of C++ containers">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def InvalidatedIteratorChecker : Checker<"InvalidatedIterator">,
   HelpText<"Check for use of invalidated iterators">,
   Dependencies<[IteratorModeling]>,
   Documentation<HasAlphaDocumentation>;
 
 def IteratorRangeChecker : Checker<"IteratorRange">,
   HelpText<"Check for iterators used outside their valid ranges">,

 //===----------------------------------------------------------------------===//
 // Valist checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = Valist in {
 
 def ValistBase : Checker<"ValistBase">,
   HelpText<"Gathers information about va_lists.">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def UninitializedChecker : Checker<"Uninitialized">,
   HelpText<"Check for usages of uninitialized (or already released) va_lists.">,
   Dependencies<[ValistBase]>,
   Documentation<NotDocumented>;
 
 def UnterminatedChecker : Checker<"Unterminated">,
   HelpText<"Check for va_lists which are not released by a va_end call.">,

 //===----------------------------------------------------------------------===//
 // Security checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = InsecureAPI in {
 
 def SecuritySyntaxChecker : Checker<"SecuritySyntaxChecker">,
   HelpText<"Base of various security function related checkers">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def bcmp : Checker<"bcmp">,
   HelpText<"Warn on uses of the 'bcmp' function">,
   Dependencies<[SecuritySyntaxChecker]>,
   Documentation<HasDocumentation>;
 
 def bcopy : Checker<"bcopy">,
   HelpText<"Warn on uses of the 'bcopy' function">,

 //===----------------------------------------------------------------------===//
 // Mac OS X, Cocoa, and Core Foundation checkers.
 //===----------------------------------------------------------------------===//
 
 let ParentPackage = Cocoa in {
 
 def RetainCountBase : Checker<"RetainCountBase">,
   HelpText<"Common base of various retain count related checkers">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 } // end "osx.cocoa"
 
 let ParentPackage = OSX in {
 
 def NSOrCFErrorDerefChecker : Checker<"NSOrCFErrorDerefChecker">,
   HelpText<"Implementation checker for NSErrorChecker and CFErrorChecker">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def NumberObjectConversionChecker : Checker<"NumberObjectConversion">,
   HelpText<"Check for erroneous conversions of objects representing numbers "
            "into numbers">,
   CheckerOptions<[
     CmdLineOption<Boolean,
                   "Pedantic",
                   "Enables detection of more conversion patterns (which are "

 } // end "optin.osx"
 
 let ParentPackage = CocoaAlpha in {
 
 def IvarInvalidationModeling : Checker<"IvarInvalidationModeling">,
   HelpText<"Gathers information for annotation driven invalidation checking "
            "for classes that contains a method annotated with "
            "'objc_instance_variable_invalidator'">,
-  Documentation<NotDocumented>;
+  Documentation<NotDocumented>,
+  Hidden;
 
 def InstanceVariableInvalidation : Checker<"InstanceVariableInvalidation">,
   HelpText<"Check that the invalidatable instance variables are invalidated in "
            "the methods annotated with objc_instance_variable_invalidator">,
   Dependencies<[IvarInvalidationModeling]>,
   Documentation<HasAlphaDocumentation>;
 
 def MissingInvalidationMethod : Checker<"MissingInvalidationMethod">,

cfe/trunk/include/clang/StaticAnalyzer/Core/AnalyzerOptions.h

public:
   /// Disable all analyzer checks.
   ///
   /// This flag allows one to disable analyzer checks on the code processed by
   /// the given analysis consumer. Note, the code will get parsed and the
   /// command-line options will get checked.
   unsigned DisableAllChecks : 1;
 
   unsigned ShowCheckerHelp : 1;
+  unsigned ShowCheckerHelpHidden : 1;
   unsigned ShowEnabledCheckerList : 1;
   unsigned ShowConfigOptionsList : 1;
   unsigned ShouldEmitErrorsOnInvalidConfigValue : 1;
   unsigned AnalyzeAll : 1;
   unsigned AnalyzerDisplayProgress : 1;
   unsigned AnalyzeNestedBlocks : 1;
 
   unsigned eagerlyAssumeBinOpBifurcation : 1;

cfe/trunk/include/clang/StaticAnalyzer/Frontend/CheckerRegistry.h

struct CheckerInfo {
     };
 
     InitializationFunction Initialize = nullptr;
     ShouldRegisterFunction ShouldRegister = nullptr;
     StringRef FullName;
     StringRef Desc;
     StringRef DocumentationUri;
     CmdLineOptionList CmdLineOptions;
+    bool IsHidden = false;
     StateFromCmdLine State = StateFromCmdLine::State_Unspecified;
 
     ConstCheckerInfoList Dependencies;
 
     bool isEnabled(const LangOptions &LO) const {
       return State == StateFromCmdLine::State_Enabled && ShouldRegister(LO);
     }
 
     bool isDisabled(const LangOptions &LO) const {
       return State == StateFromCmdLine::State_Disabled && ShouldRegister(LO);
     }
 
     CheckerInfo(InitializationFunction Fn, ShouldRegisterFunction sfn,
-                StringRef Name, StringRef Desc, StringRef DocsUri)
+                StringRef Name, StringRef Desc, StringRef DocsUri,
+                bool IsHidden)
         : Initialize(Fn), ShouldRegister(sfn), FullName(Name), Desc(Desc),
-          DocumentationUri(DocsUri) {}
+          DocumentationUri(DocsUri), IsHidden(IsHidden) {}
 
     // Used for lower_bound.
     explicit CheckerInfo(StringRef FullName) : FullName(FullName) {}
   };
 
   using StateFromCmdLine = CheckerInfo::StateFromCmdLine;
 
   /// Specifies a package. Each package option is implicitly an option for all
private:
   template <typename T> static bool returnTrue(const LangOptions &LO) {
     return true;
   }
 
 public:
   /// Adds a checker to the registry. Use this non-templated overload when your
   /// checker requires custom initialization.
   void addChecker(InitializationFunction Fn, ShouldRegisterFunction sfn,
-                  StringRef FullName, StringRef Desc, StringRef DocsUri);
+                  StringRef FullName, StringRef Desc, StringRef DocsUri,
+                  bool IsHidden);
 
   /// 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, StringRef DocsUri) {
+  void addChecker(StringRef FullName, StringRef Desc, StringRef DocsUri,
+                  bool IsHidden = false) {
     // Avoid MSVC's Compiler Error C2276:
     // http://msdn.microsoft.com/en-us/library/850cstw1(v=VS.80).aspx
     addChecker(&CheckerRegistry::initializeManager<T>,
-               &CheckerRegistry::returnTrue<T>, FullName, Desc, DocsUri);
+               &CheckerRegistry::returnTrue<T>, FullName, Desc, DocsUri,
+               IsHidden);
   }
 
   /// Makes the checker with the full name \p fullName depends on the checker
   /// called \p dependency.
   void addDependency(StringRef FullName, StringRef Dependency);
 
   /// Registers an option to a given checker. A checker option will always have
   /// the following format:

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

if (Value == NumInliningModes) {
         << A->getAsString(Args) << Name;
       Success = false;
     } else {
       Opts.InliningMode = Value;
     }
   }
 
   Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
+  Opts.ShowCheckerHelpHidden = Args.hasArg(OPT_analyzer_checker_help_hidden);
   Opts.ShowConfigOptionsList = Args.hasArg(OPT_analyzer_config_help);
   Opts.ShowEnabledCheckerList = Args.hasArg(OPT_analyzer_list_enabled_checkers);
   Opts.ShouldEmitErrorsOnInvalidConfigValue =
       /* negated */!llvm::StringSwitch<bool>(
                    Args.getLastArgValue(OPT_analyzer_config_compatibility_mode))
         .Case("true", true)
         .Case("false", false)
         .Default(false);

cfe/trunk/lib/FrontendTool/ExecuteCompilerInvocation.cpp

if (!Clang->getFrontendOpts().LLVMArgs.empty()) {
     Args[0] = "clang (LLVM option parsing)";
     for (unsigned i = 0; i != NumArgs; ++i)
       Args[i + 1] = Clang->getFrontendOpts().LLVMArgs[i].c_str();
     Args[NumArgs + 1] = nullptr;
     llvm::cl::ParseCommandLineOptions(NumArgs + 1, Args.get());
   }
 
 #if CLANG_ENABLE_STATIC_ANALYZER
-  // Honor -analyzer-checker-help.
-  // This should happen AFTER plugins have been loaded!
-  if (Clang->getAnalyzerOpts()->ShowCheckerHelp) {
+  // These should happen AFTER plugins have been loaded!
+
+  AnalyzerOptions &AnOpts = *Clang->getAnalyzerOpts();
+  // Honor -analyzer-checker-help and -analyzer-checker-help-hidden.
+  if (AnOpts.ShowCheckerHelp || AnOpts.ShowCheckerHelpHidden) {
     ento::printCheckerHelp(llvm::outs(),
                            Clang->getFrontendOpts().Plugins,
-                           *Clang->getAnalyzerOpts(),
+                           AnOpts,
                            Clang->getDiagnostics(),
                            Clang->getLangOpts());
     return true;
   }
 
   // Honor -analyzer-list-enabled-checkers.
-  if (Clang->getAnalyzerOpts()->ShowEnabledCheckerList) {
+  if (AnOpts.ShowEnabledCheckerList) {
     ento::printEnabledCheckerList(llvm::outs(),
                                   Clang->getFrontendOpts().Plugins,
-                                  *Clang->getAnalyzerOpts(),
+                                  AnOpts,
                                   Clang->getDiagnostics(),
                                   Clang->getLangOpts());
   }
 
   // Honor -analyzer-config-help.
-  if (Clang->getAnalyzerOpts()->ShowConfigOptionsList) {
+  if (AnOpts.ShowConfigOptionsList) {
     ento::printAnalyzerConfigList(llvm::outs());
     return true;
   }
 #endif
 
   // If there were errors in processing arguments, don't do anything else.
   if (Clang->getDiagnostics().hasErrorOccurred())
     return false;

cfe/trunk/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp

 using namespace clang;
 using namespace ento;
 using namespace llvm;
 
 std::vector<StringRef>
 AnalyzerOptions::getRegisteredCheckers(bool IncludeExperimental /* = false */) {
   static const StringRef StaticAnalyzerChecks[] = {
 #define GET_CHECKERS
-#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI)                            \
+#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
   FULLNAME,
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER
 #undef GET_CHECKERS
   };
   std::vector<StringRef> Result;
   for (StringRef CheckName : StaticAnalyzerChecks) {
     if (!CheckName.startswith("debug.") &&

cfe/trunk/lib/StaticAnalyzer/Core/SarifDiagnostics.cpp

return json::Object{
            *Diag.getLocation().asLocation().getFileEntry(), SMgr, Files))}},
       {"ruleIndex", Iter->getValue()},
       {"ruleId", Diag.getCheckName()}};
 }
 
 static StringRef getRuleDescription(StringRef CheckName) {
   return llvm::StringSwitch<StringRef>(CheckName)
 #define GET_CHECKERS
-#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI)                            \
+#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
   .Case(FULLNAME, HELPTEXT)
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER
 #undef GET_CHECKERS
       ;
 }
 
 static StringRef getRuleHelpURIStr(StringRef CheckName) {
   return llvm::StringSwitch<StringRef>(CheckName)
 #define GET_CHECKERS
-#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI)                            \
+#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
   .Case(FULLNAME, DOC_URI)
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER
 #undef GET_CHECKERS
       ;
 }
 
 static json::Object createRule(const PathDiagnostic &Diag) {

cfe/trunk/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp

 CheckerRegistry::CheckerRegistry(
     ArrayRef<std::string> Plugins, DiagnosticsEngine &Diags,
     AnalyzerOptions &AnOpts, const LangOptions &LangOpts,
     ArrayRef<std::function<void(CheckerRegistry &)>> CheckerRegistrationFns)
     : Diags(Diags), AnOpts(AnOpts), LangOpts(LangOpts) {
 
   // Register builtin checkers.
 #define GET_CHECKERS
-#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI)                            \
+#define CHECKER(FULLNAME, CLASS, HELPTEXT, DOC_URI, IS_HIDDEN)                 \
   addChecker(register##CLASS, shouldRegister##CLASS, FULLNAME, HELPTEXT,       \
-             DOC_URI);
+             DOC_URI, IS_HIDDEN);
 
 #define GET_PACKAGES
 #define PACKAGE(FULLNAME) addPackage(FULLNAME);
 
 #include "clang/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER
 #undef GET_CHECKERS
 #undef PACKAGE
void CheckerRegistry::addPackageOption(StringRef OptionType,
                                        StringRef Description) {
   PackageOptions.emplace_back(
       PackageFullName,
       CmdLineOption{OptionType, OptionName, DefaultValStr, Description});
 }
 
 void CheckerRegistry::addChecker(InitializationFunction Rfn,
                                  ShouldRegisterFunction Sfn, StringRef Name,
-                                 StringRef Desc, StringRef DocsUri) {
-  Checkers.emplace_back(Rfn, Sfn, Name, Desc, DocsUri);
+                                 StringRef Desc, StringRef DocsUri,
+                                 bool IsHidden) {
+  Checkers.emplace_back(Rfn, Sfn, Name, Desc, DocsUri, IsHidden);
 
   // Record the presence of the checker in its packages.
   StringRef PackageName, LeafName;
   std::tie(PackageName, LeafName) = Name.rsplit(PackageSeparator);
   while (!LeafName.empty()) {
     PackageSizes[PackageName] += 1;
     std::tie(PackageName, LeafName) = PackageName.rsplit(PackageSeparator);
   }
for (const auto &Checker : Checkers) {
     //   Package.Name     Description  [Hidden]
     size_t NameLength = Checker.FullName.size();
     if (NameLength <= MaxNameChars)
       OptionFieldWidth = std::max(OptionFieldWidth, NameLength);
   }
 
   const size_t InitialPad = 2;
   for (const auto &Checker : Checkers) {
+    if (!AnOpts.ShowCheckerHelpHidden && Checker.IsHidden)
+      continue;
+
     Out.indent(InitialPad) << Checker.FullName;
 
     int Pad = OptionFieldWidth - Checker.FullName.size();
 
     // Break on long option names.
     if (Pad < 0) {
       Out << '\n';
       Pad = OptionFieldWidth + InitialPad;

cfe/trunk/test/Analysis/show-checker-list.c

+// RUN: %clang_cc1 -analyzer-checker-help \
+// RUN:   2>&1 | FileCheck %s -check-prefix=CHECK
+
+// RUN: %clang_cc1 -analyzer-checker-help-hidden \
+// RUN:   2>&1 | FileCheck %s -check-prefix=CHECK-HIDDEN
+
+// CHECK: core.DivideZero
+// CHECK-HIDDEN: core.DivideZero
+
+// CHECK-NOT: unix.DynamicMemoryModeling
+// CHECK-HIDDEN: unix.DynamicMemoryModeling

cfe/trunk/utils/TableGen/ClangSACheckersEmitter.cpp

if (BitsInit *BI = R.getValueAsBitsInit("Type")) {
     }
   }
   PrintFatalError(R.getLoc(),
                   "unable to parse command line option type for "
                   + getCheckerFullName(&R));
   return "";
 }
 
+static bool isHidden(const Record *R) {
+  if (R->getValueAsBit("Hidden"))
+    return true;
+  // Not declared as hidden, check the parent package if it is hidden.
+  if (DefInit *DI = dyn_cast<DefInit>(R->getValueInit("ParentPackage")))
+    return isHidden(DI->getDef());
+
+  return false;
+}
+
 static void printChecker(llvm::raw_ostream &OS, const Record &R) {
     OS << "CHECKER(" << "\"";
     OS.write_escaped(getCheckerFullName(&R)) << "\", ";
     OS << R.getName() << ", ";
     OS << "\"";
     OS.write_escaped(getStringValue(R, "HelpText")) << "\", ";
     OS << "\"";
     OS.write_escaped(getCheckerDocs(R));
-    OS << "\"";
+    OS << "\", ";
+
+    if (!isHidden(&R))
+      OS << "false";
+    else
+      OS << "true";
+
+    OS << ")\n";
 }
 
 namespace clang {
 void EmitClangSACheckers(RecordKeeper &Records, raw_ostream &OS) {
   std::vector<Record*> checkers = Records.getAllDerivedDefinitions("Checker");
   std::vector<Record*> packages = Records.getAllDerivedDefinitions("Package");
 
   using SortedRecords = llvm::StringMap<const Record *>;
void EmitClangSACheckers(RecordKeeper &Records, raw_ostream &OS) {
   //   - CLASS: The name of the checker, with "Checker" appended, e.g.:
   //            UninitializedObjectChecker
   //   - HELPTEXT: The description of the checker.
   OS << "\n"
         "#ifdef GET_CHECKERS\n"
         "\n";
   for (const Record *checker : checkers) {
     printChecker(OS, *checker);
-    OS << ")\n";
   }
   OS << "\n"
         "#endif // GET_CHECKERS\n"
         "\n";
 
   // Emit dependencies.
   //
   // CHECKER_DEPENDENCY(FULLNAME, DEPENDENCY)