Correct behavior of __builtin_*_overflow and constexpr.

[erichkeane]

Summary

Enable these builtins to be called across a lambda
boundary, as brought up by Eli here: https://reviews.llvm.org/D48040

[efriedma]

lib/Sema/SemaChecking.cpp

228

Is it possible for this initialization to fail? If it can't fail, please add an assertion; otherwise, you probably need to "return true". (Not sure off the top of my head how that would happen; maybe it would error out on a volatile int*?)

[erichkeane]

Add error checking to perform copy init.

lib/Sema/SemaChecking.cpp

228

You're correct, it apparently can fail! I've added a test to return true. Based on a reading of the code, performcopyinit diagnoses, so I think this patch should be correct.

[efriedma]

LGTM

lib/Sema/SemaChecking.cpp

 }
 
 static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall) {
   if (checkArgCount(S, TheCall, 3))
     return true;
 
   // First two arguments should be integers.
   for (unsigned I = 0; I < 2; ++I) {
-    Expr *Arg = TheCall->getArg(I);
-    QualType Ty = Arg->getType();
+    ExprResult Arg = TheCall->getArg(I);
+    QualType Ty = Arg.get()->getType();
     if (!Ty->isIntegerType()) {
-      S.Diag(Arg->getLocStart(), diag::err_overflow_builtin_must_be_int)
-          << Ty << Arg->getSourceRange();
+      S.Diag(Arg.get()->getLocStart(), diag::err_overflow_builtin_must_be_int)
+          << Ty << Arg.get()->getSourceRange();
       return true;
     }
+    InitializedEntity Entity = InitializedEntity::InitializeParameter(
+        S.getASTContext(), Ty, /*consume*/ false);
+    Arg = S.PerformCopyInitialization(Entity, SourceLocation(), Arg);
+    TheCall->setArg(I, Arg.get());
   }
 
   // Third argument should be a pointer to a non-const integer.
   // IRGen correctly handles volatile, restrict, and address spaces, and
   // the other qualifiers aren't possible.
   {
-    Expr *Arg = TheCall->getArg(2);
-    QualType Ty = Arg->getType();
+    ExprResult Arg = TheCall->getArg(2);
+    QualType Ty = Arg.get()->getType();
     const auto *PtrTy = Ty->getAs<PointerType>();
     if (!(PtrTy && PtrTy->getPointeeType()->isIntegerType() &&
           !PtrTy->getPointeeType().isConstQualified())) {
-      S.Diag(Arg->getLocStart(), diag::err_overflow_builtin_must_be_ptr_int)
-          << Ty << Arg->getSourceRange();
+      S.Diag(Arg.get()->getLocStart(), diag::err_overflow_builtin_must_be_ptr_int)
+          << Ty << Arg.get()->getSourceRange();
       return true;
     }
+      InitializedEntity Entity = InitializedEntity::InitializeParameter(
+          S.getASTContext(), Ty, /*consume*/ false);
+      Arg = S.PerformCopyInitialization(Entity, SourceLocation(), Arg);
+      TheCall->setArg(2, Arg.get());
   }
 
   return false;
 }
 
 static void SemaBuiltinMemChkCall(Sema &S, FunctionDecl *FDecl,
                       CallExpr *TheCall, unsigned SizeIdx,
                                   unsigned DstSizeIdx) {

test/SemaCXX/builtins-overflow.cpp

+// RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify %s
+// expected-no-diagnostics
+
+int a() {
+  const int x = 3;
+  static int z;
+  constexpr int *y = &z;
+  return []() { return __builtin_sub_overflow((int)x, (int)x, (int *)y); }();
+}
+int a2() {
+  const int x = 3;
+  static int z;
+  constexpr int *y = &z;
+  return []() { return __builtin_sub_overflow(x, x, y); }();
+}