[Clang][Sema] Avoid crashing for `__builtin_memcpy_inline` with an array argument

[egorzhdan]

Summary

This change teaches the Sema logic for __builtin_memcpy_inline to implicitly convert arrays passed as arguments to pointers, similarly to regular memcpy.

This code will no longer cause a compiler crash:

void f(char *p) {
    char s[1] = {0};
    __builtin_memcpy_inline(p, s, 1);
}

rdar://88147527

[gchatelet]

Thx for the patch, please address the comment before submitting.

clang/lib/Sema/SemaChecking.cpp

1946–1953

[nit] It's unclear looking at the function name that it's failing when returning true - one has to read the code to understand. It may be fine now but could become messy with time and refactoring.
Either change the lambda's name FailArgArrayConversion or negate everything.

[egorzhdan]

Rename a lambda to improve readability

[gchatelet]

Much better, thank you.

clang/lib/Sema/SemaChecking.cpp

Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID,
   case Builtin::BI__sync_synchronize:
     Diag(TheCall->getBeginLoc(), diag::warn_atomic_implicit_seq_cst)
         << TheCall->getCallee()->getSourceRange();
     break;
   case Builtin::BI__builtin_nontemporal_load:
   case Builtin::BI__builtin_nontemporal_store:
     return SemaBuiltinNontemporalOverloaded(TheCallResult);
   case Builtin::BI__builtin_memcpy_inline: {
+    auto ArgArrayConversionFailed = [&](unsigned Arg) {
+      ExprResult ArgExpr =
+          DefaultFunctionArrayLvalueConversion(TheCall->getArg(Arg));
+      if (ArgExpr.isInvalid())
+        return true;
+      TheCall->setArg(Arg, ArgExpr.get());
+      return false;
+    };
+
+    if (ArgArrayConversionFailed(0) || ArgArrayConversionFailed(1))
+      return true;
     clang::Expr *SizeOp = TheCall->getArg(2);
     // We warn about copying to or from `nullptr` pointers when `size` is
     // greater than 0. When `size` is value dependent we cannot evaluate its
     // value so we bail out.
     if (SizeOp->isValueDependent())
       break;
     if (!SizeOp->EvaluateKnownConstInt(Context).isZero()) {
       CheckNonNullArgument(*this, TheCall->getArg(0), TheCall->getExprLoc());

clang/test/Sema/builtins-memcpy-inline.cpp

void test_memcpy_inline_non_constant_size(void *dst, const void *src, unsigned size) {
   __builtin_memcpy_inline(dst, src, size); // expected-error {{argument to '__builtin_memcpy_inline' must be a constant integer}}
 }
 
 template <unsigned size>
 void test_memcpy_inline_template(void *dst, const void *src) {
   // we do not try to evaluate size in non intantiated templates.
   __builtin_memcpy_inline(dst, src, size);
 }
+
+void test_memcpy_inline_implicit_conversion(void *ptr) {
+  char a[5];
+  __builtin_memcpy_inline(ptr, a, 5);
+  __builtin_memcpy_inline(a, ptr, 5);
+}