[analyzer] Add CTUImportCppThreshold for C++ files

[martong]

Summary

The default CTUImportThreshold (8) seems to be too conservative with C projects.
We increase this value to 24 and we introduce another threshold for C++ source
files (defaulted to 8) because their AST is way more compilcated than C source
files.

[gamesh411]

It will be interesting to see how different C and C++ projects will prove in terms of AST complexity, and Decl-size, but I understand that for now, these two options are necessary to not penalize C project analysis because of C++ AST complexity.

[gamesh411]

clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.def

333

extra whitespace at the end

[martong]

• Remove extra whitespace

[Szelethus]

clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.def

48–50

This reminds me of some options having different default values depending on -analyzer-config user-mode. I think that solution, and the one proposed in this patch is subpar, but the best solution, turning this entire thing into a TableGen file, would be a chore.

[Szelethus]

I don't like this solution toooo much, but I respect the urgency, and since we don't introduce a compatibility issue, I trust we can remove this if we decide to change to TableGen. Post-commit LGTM!

clang/include/clang/StaticAnalyzer/Core/AnalyzerOptions.def

 ///   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.
 #define ANALYZER_OPTION(TYPE, NAME, CMDFLAG, DESC, DEFAULT_VAL)
 #endif
 
 #ifndef ANALYZER_OPTION_DEPENDS_ON_USER_MODE
 /// Create a new analyzer option, but dont generate a method for it in
 /// AnalyzerOptions. It's value depends on the option "user-mode".
 ///
 ///   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)

 
 //===----------------------------------------------------------------------===//
 // Unsigned analyzer options.
 //===----------------------------------------------------------------------===//
 
 ANALYZER_OPTION(unsigned, CTUImportThreshold, "ctu-import-threshold",
                 "The maximal amount of translation units that is considered "
                 "for import when inlining functions during CTU analysis. "
-                "Lowering this threshold can alleviate the memory burder of "
+                "Lowering this threshold can alleviate the memory burden of "
                 "analysis with many interdependent definitions located in "
-                "various translation units.",
+                "various translation units. This is valid only for non C++ "
+                "source files.",
+                24u)
+
+ANALYZER_OPTION(unsigned, CTUImportCppThreshold, "ctu-import-cpp-threshold",
+                "The maximal amount of translation units that is considered "
+                "for import when inlining functions during CTU analysis of C++ "
+                "source files.",
                 8u)
 
 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)
 

clang/lib/CrossTU/CrossTranslationUnit.cpp

default:
     break;
   }
 }
 
 CrossTranslationUnitContext::ASTUnitStorage::ASTUnitStorage(
     CompilerInstance &CI)
     : Loader(CI, CI.getAnalyzerOpts()->CTUDir,
              CI.getAnalyzerOpts()->CTUInvocationList),
-      LoadGuard(CI.getAnalyzerOpts()->CTUImportThreshold) {}
+      LoadGuard(CI.getASTContext().getLangOpts().CPlusPlus
+                    ? CI.getAnalyzerOpts()->CTUImportCppThreshold
+                    : CI.getAnalyzerOpts()->CTUImportThreshold) {}
 
 llvm::Expected<ASTUnit *>
 CrossTranslationUnitContext::ASTUnitStorage::getASTUnitForFile(
     StringRef FileName, bool DisplayCTUProgress) {
   // Try the cache first.
   auto ASTCacheEntry = FileASTUnitMap.find(FileName);
   if (ASTCacheEntry == FileASTUnitMap.end()) {
 

clang/test/Analysis/analyzer-config.c

 // CHECK-NEXT: core.CallAndMessage:FunctionPointer = true
 // CHECK-NEXT: core.CallAndMessage:NilReceiver = true
 // CHECK-NEXT: core.CallAndMessage:ParameterCount = true
 // CHECK-NEXT: core.CallAndMessage:UndefReceiver = true
 // CHECK-NEXT: cplusplus.Move:WarnOn = KnownsAndLocals
 // CHECK-NEXT: cplusplus.SmartPtrModeling:ModelSmartPtrDereference = false
 // CHECK-NEXT: crosscheck-with-z3 = false
 // CHECK-NEXT: ctu-dir = ""
-// CHECK-NEXT: ctu-import-threshold = 8
+// CHECK-NEXT: ctu-import-cpp-threshold = 8
+// CHECK-NEXT: ctu-import-threshold = 24
 // CHECK-NEXT: ctu-index-name = externalDefMap.txt
 // CHECK-NEXT: ctu-invocation-list = invocations.yaml
 // CHECK-NEXT: deadcode.DeadStores:ShowFixIts = false
 // CHECK-NEXT: deadcode.DeadStores:WarnForDeadNestedAssignments = true
 // CHECK-NEXT: debug.AnalysisOrder:* = false
 // CHECK-NEXT: debug.AnalysisOrder:Bind = false
 // CHECK-NEXT: debug.AnalysisOrder:EndAnalysis = false
 // CHECK-NEXT: debug.AnalysisOrder:EndFunction = false

clang/test/Analysis/ctu-import-threshold.c

 // Ensure analyzer option 'ctu-import-threshold' is a recognized option.
 //
 // RUN: %clang_cc1 -analyze -analyzer-config ctu-import-threshold=30 -verify %s
+// RUN: %clang_cc1 -analyze -analyzer-config ctu-import-cpp-threshold=30 -verify %s
 //
 // expected-no-diagnostics

clang/unittests/CrossTU/CrossTranslationUnitTest.cpp

 public:
   CTUAction(bool *Success, unsigned OverrideLimit)
       : Success(Success), OverrideLimit(OverrideLimit) {}
 
 protected:
   std::unique_ptr<clang::ASTConsumer>
   CreateASTConsumer(clang::CompilerInstance &CI, StringRef) override {
     CI.getAnalyzerOpts()->CTUImportThreshold = OverrideLimit;
+    CI.getAnalyzerOpts()->CTUImportCppThreshold = OverrideLimit;
     return std::make_unique<CTUASTConsumer>(CI, Success);
   }
 
 private:
   bool *Success;
   const unsigned OverrideLimit;
 };