[CFG] [analyzer] pr37769: Disable argument construction contexts for variadic functions.

[NoQ]

Summary

The analyzer doesn't make use of them anyway and they seem to have pretty weird AST from time to time, so let's just skip them for now.

Fixes the assertion failure in https://bugs.llvm.org/show_bug.cgi?id=38427.

lib/Analysis/CFG.cpp

CFGBlock *CFGBuilder::VisitCallExpr(CallExpr *C, AddStmtChoice asc) {
   if (calleeType == Context->BoundMemberTy) {
     QualType boundType = Expr::findBoundMemberType(C->getCallee());
 
     // We should only get a null bound type if processing a dependent
     // CFG.  Recover by assuming nothing.
     if (!boundType.isNull()) calleeType = boundType;
   }
 
-  findConstructionContextsForArguments(C);
-
   // If this is a call to a no-return function, this stops the block here.
   bool NoReturn = getFunctionExtInfo(*calleeType).getNoReturn();
 
   bool AddEHEdge = false;
 
   // Languages without exceptions are assumed to not throw.
   if (Context->getLangOpts().Exceptions) {
     if (BuildOpts.AddEHEdges)
       AddEHEdge = true;
   }
 
   // If this is a call to a builtin function, it might not actually evaluate
   // its arguments. Don't add them to the CFG if this is the case.
   bool OmitArguments = false;
 
   if (FunctionDecl *FD = C->getDirectCallee()) {
+    // TODO: Support construction contexts for variadic function arguments.
+    // These are a bit problematic and not very useful because passing
+    // C++ objects as C-style variadic arguments doesn't work in general
+    // (see [expr.call]).
+    if (!FD->isVariadic())
+      findConstructionContextsForArguments(C);
+
     if (FD->isNoReturn() || C->isBuiltinAssumeFalse(*Context))
       NoReturn = true;
     if (FD->hasAttr<NoThrowAttr>())
       AddEHEdge = false;
     if (FD->getBuiltinID() == Builtin::BI__builtin_object_size)
       OmitArguments = true;
   }
 

test/Analysis/cfg-rich-constructors.cpp

 // CXX11-NEXT:    12: [B1.6] + [B1.11] (OperatorCall)
 // CXX17-NEXT:     8: [B1.7] (CXXConstructExpr, [B1.10]+1, class operators::C)
 // CXX17-NEXT:     9: operators::C([B1.8]) (CXXFunctionalCastExpr, ConstructorConversion, class operato
 // CXX17-NEXT:    10: [B1.6] + [B1.9] (OperatorCall)
 void testOperators() {
   C(1) + C(2);
 }
 } // namespace operators
+
+namespace variadic_function_arguments {
+class C {
+ public:
+  C(int);
+};
+
+int variadic(...);
+
+// This code is quite exotic, so let's not test the CFG for it,
+// but only make sure we don't crash.
+void testCrashOnVariadicArgument() {
+  C c(variadic(0 ? c : 0)); // no-crash
+}
+} // namespace variadic_function_arguments