[analyzer] Do not crash on callback for call_once passed by value

[george.karpenkov]

Summary

https://bugs.llvm.org/show_bug.cgi?id=37312
rdar://40270582

[NoQ]

Am i understanding correctly that the whole point is that you don't need function to pointer decay when there's already a function pointer?

Sounds reasonable.

[george.karpenkov]

that you don't need function to pointer decay when there's already a function pointer?

Yes. Weird though that we haven't seen this case before, I'm still not entirely sure why.

cfe/trunk/lib/Analysis/BodyFarm.cpp

 typedef Stmt *(*FunctionFarmer)(ASTContext &C, const FunctionDecl *D);
 
 static CallExpr *create_call_once_funcptr_call(ASTContext &C, ASTMaker M,
                                                const ParmVarDecl *Callback,
                                                ArrayRef<Expr *> CallArgs) {
 
   QualType Ty = Callback->getType();
   DeclRefExpr *Call = M.makeDeclRefExpr(Callback);
-  CastKind CK;
+  Expr *SubExpr;
   if (Ty->isRValueReferenceType()) {
-    CK = CK_LValueToRValue;
-  } else {
-    assert(Ty->isLValueReferenceType());
-    CK = CK_FunctionToPointerDecay;
+    SubExpr = M.makeImplicitCast(
+        Call, Ty.getNonReferenceType(), CK_LValueToRValue);
+  } else if (Ty->isLValueReferenceType() &&
+             Call->getType()->isFunctionType()) {
     Ty = C.getPointerType(Ty.getNonReferenceType());
+    SubExpr = M.makeImplicitCast(Call, Ty, CK_FunctionToPointerDecay);
+  } else if (Ty->isLValueReferenceType()
+             && Call->getType()->isPointerType()
+             && Call->getType()->getPointeeType()->isFunctionType()){
+    SubExpr = Call;
+  } else {
+    llvm_unreachable("Unexpected state");
   }
 
   return new (C)
-      CallExpr(C, M.makeImplicitCast(Call, Ty.getNonReferenceType(), CK),
-               /*args=*/CallArgs,
-               /*QualType=*/C.VoidTy,
-               /*ExprValueType=*/VK_RValue,
-               /*SourceLocation=*/SourceLocation());
+      CallExpr(C, SubExpr, CallArgs, C.VoidTy, VK_RValue, SourceLocation());
 }
 
 static CallExpr *create_call_once_lambda_call(ASTContext &C, ASTMaker M,
                                               const ParmVarDecl *Callback,
                                               CXXRecordDecl *CallbackDecl,
                                               ArrayRef<Expr *> CallArgs) {
   assert(CallbackDecl != nullptr);
   assert(CallbackDecl->isLambda());

cfe/trunk/test/Analysis/call_once.cpp

 }
 
 // The provided callback expects an std::function, but instead a C function
 // name is provided, and C++ implicitly auto-constructs a pointer from it.
 void callback_with_implicit_cast() {
   std::once_flag flag;
   call_once(flag, callback_taking_func, callback_with_implicit_cast);
 }
+
+std::once_flag another_once_flag;
+typedef void (*my_callback_t)(int *);
+my_callback_t callback;
+int global_int;
+
+void rdar40270582() {
+  call_once(another_once_flag, callback, &global_int);
+}