[PATCH] c++: Allow overloaded builtins to be used in SFINAE context

[mmalcomson@nvidia.com]

From: Matthew Malcomson <mmalcomson@nvidia.com>

This commit newly introduces the ability to use overloaded builtins in
C++ SFINAE context.

The goal behind this is in order to ensure there is a single mechanism
that libstdc++ can use to determine whether a given type can be used in
the atomic fetch_add (and similar) builtins.  I am working on another
patch that hopes to use this mechanism to identify whether fetch_add
(and similar) work on floating point types.

Current state of the world:

    GCC currently exposes resolved versions of these builtins to the
    user, so for GCC it's currently possible to use tests similar to the
    below to check for atomic loads on a 2 byte sized object.
      #if __has_builtin(__atomic_load_2)
    Clang does not expose resolved versions of the atomic builtins.

    clang currently allows SFINAE on builtins, so that C++ code can
    check whether a builtin is available on a given type.
    GCC does not (and that is what this patch aims to change).

    Libraries like libatomic can check whether a given atomic builtin
    can work on a given type by using autoconf to check for a
    miscompilation when attempting such a use.

My goal:
    I would like to enable floating point fetch_add (and similar) in
    GCC, in order to use those overloads in libstdc++ implementation of
    atomic<float>::fetch_add.
    This should allow compilers targeting GPU's which have floating
    point fetch_add instructions to emit optimal code.

    In order to do that I need some consistent mechanism that libstdc++
    can use to identify whether the fetch_add builtins have floating
    point overloads (and for which types these exist).

    I would hence like to enable SFINAE on builtins, so that libstdc++
    can use that mechanism for the floating point fetch_add builtins.
    Discussion with J Wakely about which approach to take for libstdc++:
    https://gcc.gnu.org/pipermail/gcc-patches/2024-October/664363.html

Implementation follows the existing mechanism for handling SFINAE
contexts in c-common.cc.  A boolean is passed into the c-common.cc
function indicating whether these functions should emit errors or not.
This boolean comes from `complain & tf_error` in the C++ frontend.
(Similar to other functions like valid_array_size_p and
c_build_vec_perm_expr).

This is done both for resolve_overloaded_builtin and
check_builtin_function_arguments, both of which can be used in SFINAE
contexts.
    N.b. I attempted to trigger something using the `reject_gcc_builtin`
    function in an SFINAE context.  Given the context where this
    function is called from the C++ frontend it looks like it may be
    possible, but I did not manage to trigger this in template context
    by attempting to do something similar to the testcases added around
    those calls.
    - I would appreciate any feedback on whether this is something that
      can happen in a template context, and if so some help writing a
      relevant testcase for it.

Both of these functions have target hooks for target specific builtins
that I have updated to take the extra boolean flag.  I have not adjusted
the functions implementing those target hooks (except to update the
declarations) so target specific builtins will still error in SFINAE
contexts.
- N.b. I could imagine not updating the target hook definition since
  nothing would use that change.  However I figure that allowing targets
  to decide this behaviour would be the right thing to do eventually,
  and since this is the target-independent part of the change to do that
  this patch should make that change.
  Could adjust if others disagree.

Other relevant points that I'd appreciate reviewers check:
- I did not pass this new flag through
  atomic_bitint_fetch_using_cas_loop since the _BitInt type is not
  available in the C++ frontend and I didn't want if conditions that can
  not be executed in the source.
- I only test non-compile-time-constant types with SVE types, since I do
  not know of a way to get a VLA into a SFINAE context.
- While writing tests I noticed a few differences with clang in this
  area.  I don't think they are problematic but am mentioning them for
  completeness and to allow others to judge if these are a problem).
  - atomic_fetch_add on a boolean is allowed by clang.
  - With SFINAE GCC is happy with multiple definitions of a differently
    typed template as long as they aren't instantiated, while clang is
    not.  This seems to be a general difference around clang and GCC and
    not specific to builtins.
    I.e. two template definitions with the same name where one
    specialises on `myfunc (std::declval<T>())` and another on
    `myfunc (std::declval<T>(), std::declval<T>())` will not give an
    error in GCC unless one attempts to instantiate the template.
    However it will give an error in clang on the template redefinition.
- I do not block the warning about using
  __builtin_speculation_safe_value on a target that does not have any
  active mitigation defined.  I do this since when this happens we do
  not return error_mark_node, which means that if a user attempted to
  use SFINAE to check for this situation that would silently fail if the
  warning were suppressed.
  N.b. this is also a warning rather than an error.
  Similarly I do not block the warning about an invalid memory model
  argument in get_atomic_generic_size.

Bootstrap and regression tested on AArch64 and x86_64.
Built first stage on targets whose target hook declaration needed
updated (though did not regtest etc).  Targets triplets I built in order
to check the backend specific changes I made:
   - arm-none-linux-gnueabihf
   - avr-linux-gnu
   - riscv-linux-gnu
   - powerpc-linux-gnu
   - s390x-linux-gnu

Ok for commit to trunk?

gcc/c-family/ChangeLog:

	* c-common.cc (builtin_function_validate_nargs,
	check_builtin_function_arguments,
	speculation_safe_value_resolve_call,
	speculation_safe_value_resolve_params, sync_resolve_size,
	sync_resolve_params, get_atomic_generic_size,
	resolve_overloaded_atomic_exchange,
	resolve_overloaded_atomic_compare_exchange,
	resolve_overloaded_atomic_load, resolve_overloaded_atomic_store,
	resolve_overloaded_builtin):  Add `complain` boolean parameter
	and determine whether to emit errors based on its value.
	* c-common.h (check_builtin_function_arguments,
	resolve_overloaded_builtin):  Mention `complain` boolean
	parameter in declarations.  Give it a default of `true`.

gcc/ChangeLog:

	* config/aarch64/aarch64-c.cc
	(aarch64_resolve_overloaded_builtin,aarch64_check_builtin_call):
	Add new unused boolean parameter to match target hook
	definition.
	* config/arm/arm-builtins.cc (arm_check_builtin_call): Likewise.
	* config/arm/arm-c.cc (arm_resolve_overloaded_builtin):
	Likewise.
	* config/arm/arm-protos.h (arm_check_builtin_call): Likewise.
	* config/avr/avr-c.cc (avr_resolve_overloaded_builtin):
	Likewise.
	* config/riscv/riscv-c.cc (riscv_check_builtin_call,
	riscv_resolve_overloaded_builtin): Likewise.
	* config/rs6000/rs6000-c.cc (altivec_resolve_overloaded_builtin):
	Likewise.
	* config/rs6000/rs6000-protos.h (altivec_resolve_overloaded_builtin):
	Likewise.
	* config/s390/s390-c.cc (s390_resolve_overloaded_builtin):
	Likewise.
	* doc/tm.texi: Regenerate.
	* target.def (TARGET_RESOLVE_OVERLOADED_BUILTIN,
	TARGET_CHECK_BUILTIN_CALL): Update prototype to include a
	boolean parameter that indicates whether errors should be
	emitted.  Update documentation to mention this fact.

gcc/cp/ChangeLog:

	* call.cc (build_cxx_call):  Pass `complain` parameter to
	check_builtin_function_arguments.  Take its value from the
	`tsubst_flags_t` type `complain & tf_error`.
	* semantics.cc (finish_call_expr):  Pass `complain` parameter to
	resolve_overloaded_builtin.  Take its value from the
	`tsubst_flags_t` type `complain & tf_error`.

gcc/testsuite/ChangeLog:

	* g++.dg/template/builtin-atomic-overloads.def: New test.
	* g++.dg/template/builtin-atomic-overloads1.C: New test.
	* g++.dg/template/builtin-atomic-overloads2.C: New test.
	* g++.dg/template/builtin-atomic-overloads3.C: New test.
	* g++.dg/template/builtin-atomic-overloads4.C: New test.
	* g++.dg/template/builtin-atomic-overloads5.C: New test.
	* g++.dg/template/builtin-atomic-overloads6.C: New test.
	* g++.dg/template/builtin-atomic-overloads7.C: New test.
	* g++.dg/template/builtin-sfinae-check-function-arguments.C: New test.
	* g++.dg/template/builtin-speculation-overloads.def: New test.
	* g++.dg/template/builtin-speculation-overloads1.C: New test.
	* g++.dg/template/builtin-speculation-overloads2.C: New test.
	* g++.dg/template/builtin-speculation-overloads3.C: New test.
	* g++.dg/template/builtin-speculation-overloads4.C: New test.
	* g++.dg/template/builtin-speculation-overloads5.C: New test.
	* g++.dg/template/builtin-validate-nargs.C: New test.

Signed-off-by: Matthew Malcomson <mmalcomson@nvidia.com>
---
 gcc/c-family/c-common.cc                      | 459 +++++++++++-------
 gcc/c-family/c-common.h                       |   8 +-
 gcc/config/aarch64/aarch64-c.cc               |   6 +-
 gcc/config/arm/arm-builtins.cc                |   2 +-
 gcc/config/arm/arm-c.cc                       |   2 +-
 gcc/config/arm/arm-protos.h                   |   2 +-
 gcc/config/avr/avr-c.cc                       |   3 +-
 gcc/config/riscv/riscv-c.cc                   |   4 +-
 gcc/config/rs6000/rs6000-c.cc                 |   2 +-
 gcc/config/rs6000/rs6000-protos.h             |   3 +-
 gcc/config/s390/s390-c.cc                     |   5 +-
 gcc/cp/call.cc                                |   3 +-
 gcc/cp/semantics.cc                           |   3 +-
 gcc/doc/tm.texi                               |  11 +-
 gcc/target.def                                |  13 +-
 .../template/builtin-atomic-overloads.def     | 159 ++++++
 .../template/builtin-atomic-overloads1.C      |  24 +
 .../template/builtin-atomic-overloads2.C      |  18 +
 .../template/builtin-atomic-overloads3.C      |  19 +
 .../template/builtin-atomic-overloads4.C      |  19 +
 .../template/builtin-atomic-overloads5.C      | 329 +++++++++++++
 .../template/builtin-atomic-overloads6.C      | 171 +++++++
 .../template/builtin-atomic-overloads7.C      | 170 +++++++
 .../builtin-sfinae-check-function-arguments.C | 145 ++++++
 .../builtin-speculation-overloads.def         |  30 ++
 .../template/builtin-speculation-overloads1.C |  18 +
 .../template/builtin-speculation-overloads2.C |  19 +
 .../template/builtin-speculation-overloads3.C |  20 +
 .../template/builtin-speculation-overloads4.C |  19 +
 .../template/builtin-speculation-overloads5.C |  33 ++
 .../g++.dg/template/builtin-validate-nargs.C  |  67 +++
 31 files changed, 1595 insertions(+), 191 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-atomic-overloads.def
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-atomic-overloads1.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-atomic-overloads2.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-atomic-overloads3.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-atomic-overloads4.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-atomic-overloads5.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-atomic-overloads6.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-atomic-overloads7.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-sfinae-check-function-arguments.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-speculation-overloads.def
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-speculation-overloads1.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-speculation-overloads2.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-speculation-overloads3.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-speculation-overloads4.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-speculation-overloads5.C
 create mode 100644 gcc/testsuite/g++.dg/template/builtin-validate-nargs.C

diff --git a/gcc/c-family/c-common.cc b/gcc/c-family/c-common.cc
index ec6a5da892d..90550dfbeac 100644
--- a/gcc/c-family/c-common.cc
+++ b/gcc/c-family/c-common.cc
@@ -6313,16 +6313,18 @@ check_function_arguments_recurse (void (*callback)
 
 static bool
 builtin_function_validate_nargs (location_t loc, tree fndecl, int nargs,
-				 int required)
+				 int required, bool complain)
 {
   if (nargs < required)
     {
-      error_at (loc, "too few arguments to function %qE", fndecl);
+      if (complain)
+	error_at (loc, "too few arguments to function %qE", fndecl);
       return false;
     }
   else if (nargs > required)
     {
-      error_at (loc, "too many arguments to function %qE", fndecl);
+      if (complain)
+	error_at (loc, "too many arguments to function %qE", fndecl);
       return false;
     }
   return true;
@@ -6343,16 +6345,16 @@ builtin_function_validate_nargs (location_t loc, tree fndecl, int nargs,
 
 bool
 check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
-				  tree fndecl, tree orig_fndecl,
-				  int nargs, tree *args)
+				  tree fndecl, tree orig_fndecl, int nargs,
+				  tree *args, bool complain)
 {
   if (!fndecl_built_in_p (fndecl))
     return true;
 
   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
     return (!targetm.check_builtin_call
-	    || targetm.check_builtin_call (loc, arg_loc, fndecl,
-					   orig_fndecl, nargs, args));
+	    || targetm.check_builtin_call (loc, arg_loc, fndecl, orig_fndecl,
+					   nargs, args, complain));
 
   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_FRONTEND)
     return true;
@@ -6363,9 +6365,11 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
     case BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX:
       if (!tree_fits_uhwi_p (args[2]))
 	{
-	  error_at (ARG_LOCATION (2),
-		    "third argument to function %qE must be a constant integer",
-		    fndecl);
+	  if (complain)
+	    error_at (
+	      ARG_LOCATION (2),
+	      "third argument to function %qE must be a constant integer",
+	      fndecl);
 	  return false;
 	}
       /* fall through */
@@ -6388,17 +6392,18 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
 	/* Reject invalid alignments.  */
 	if (align < BITS_PER_UNIT || maxalign < align)
 	  {
-	    error_at (ARG_LOCATION (1),
-		      "second argument to function %qE must be a constant "
-		      "integer power of 2 between %qi and %qu bits",
-		      fndecl, BITS_PER_UNIT, maxalign);
+	    if (complain)
+	      error_at (ARG_LOCATION (1),
+			"second argument to function %qE must be a constant "
+			"integer power of 2 between %qi and %qu bits",
+			fndecl, BITS_PER_UNIT, maxalign);
 	    return false;
 	  }
 	return true;
       }
 
     case BUILT_IN_CONSTANT_P:
-      return builtin_function_validate_nargs (loc, fndecl, nargs, 1);
+      return builtin_function_validate_nargs (loc, fndecl, nargs, 1, complain);
 
     case BUILT_IN_ISFINITE:
     case BUILT_IN_ISINF:
@@ -6407,12 +6412,15 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
     case BUILT_IN_ISNORMAL:
     case BUILT_IN_ISSIGNALING:
     case BUILT_IN_SIGNBIT:
-      if (builtin_function_validate_nargs (loc, fndecl, nargs, 1))
+      if (builtin_function_validate_nargs (loc, fndecl, nargs, 1, complain))
 	{
 	  if (TREE_CODE (TREE_TYPE (args[0])) != REAL_TYPE)
 	    {
-	      error_at (ARG_LOCATION (0), "non-floating-point argument in "
-			"call to function %qE", fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (0),
+			  "non-floating-point argument in "
+			  "call to function %qE",
+			  fndecl);
 	      return false;
 	    }
 	  return true;
@@ -6426,7 +6434,7 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
     case BUILT_IN_ISLESSGREATER:
     case BUILT_IN_ISUNORDERED:
     case BUILT_IN_ISEQSIG:
-      if (builtin_function_validate_nargs (loc, fndecl, nargs, 2))
+      if (builtin_function_validate_nargs (loc, fndecl, nargs, 2, complain))
 	{
 	  enum tree_code code0, code1;
 	  code0 = TREE_CODE (TREE_TYPE (args[0]));
@@ -6437,8 +6445,11 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
 		|| ((code0 == INTEGER_TYPE || code0 == BITINT_TYPE)
 		    && code1 == REAL_TYPE)))
 	    {
-	      error_at (loc, "non-floating-point arguments in call to "
-			"function %qE", fndecl);
+	      if (complain)
+		error_at (loc,
+			  "non-floating-point arguments in call to "
+			  "function %qE",
+			  fndecl);
 	      return false;
 	    }
 	  return true;
@@ -6446,20 +6457,26 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
       return false;
 
     case BUILT_IN_FPCLASSIFY:
-      if (builtin_function_validate_nargs (loc, fndecl, nargs, 6))
+      if (builtin_function_validate_nargs (loc, fndecl, nargs, 6, complain))
 	{
 	  for (unsigned int i = 0; i < 5; i++)
 	    if (TREE_CODE (args[i]) != INTEGER_CST)
 	      {
-		error_at (ARG_LOCATION (i), "non-const integer argument %u in "
-			  "call to function %qE", i + 1, fndecl);
+		if (complain)
+		  error_at (ARG_LOCATION (i),
+			    "non-const integer argument %u in "
+			    "call to function %qE",
+			    i + 1, fndecl);
 		return false;
 	      }
 
 	  if (TREE_CODE (TREE_TYPE (args[5])) != REAL_TYPE)
 	    {
-	      error_at (ARG_LOCATION (5), "non-floating-point argument in "
-			"call to function %qE", fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (5),
+			  "non-floating-point argument in "
+			  "call to function %qE",
+			  fndecl);
 	      return false;
 	    }
 	  return true;
@@ -6467,14 +6484,18 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
       return false;
 
     case BUILT_IN_ASSUME_ALIGNED:
-      if (builtin_function_validate_nargs (loc, fndecl, nargs, 2 + (nargs > 2)))
+      if (builtin_function_validate_nargs (loc, fndecl, nargs, 2 + (nargs > 2),
+					   complain))
 	{
 	  if (nargs >= 3
 	      && TREE_CODE (TREE_TYPE (args[2])) != INTEGER_TYPE
 	      && TREE_CODE (TREE_TYPE (args[2])) != BITINT_TYPE)
 	    {
-	      error_at (ARG_LOCATION (2), "non-integer argument 3 in call to "
-			"function %qE", fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (2),
+			  "non-integer argument 3 in call to "
+			  "function %qE",
+			  fndecl);
 	      return false;
 	    }
 	  return true;
@@ -6484,47 +6505,63 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
     case BUILT_IN_ADD_OVERFLOW:
     case BUILT_IN_SUB_OVERFLOW:
     case BUILT_IN_MUL_OVERFLOW:
-      if (builtin_function_validate_nargs (loc, fndecl, nargs, 3))
+      if (builtin_function_validate_nargs (loc, fndecl, nargs, 3, complain))
 	{
 	  unsigned i;
 	  for (i = 0; i < 2; i++)
 	    if (!INTEGRAL_TYPE_P (TREE_TYPE (args[i])))
 	      {
-		error_at (ARG_LOCATION (i), "argument %u in call to function "
-			  "%qE does not have integral type", i + 1, fndecl);
+		if (complain)
+		  error_at (ARG_LOCATION (i),
+			    "argument %u in call to function "
+			    "%qE does not have integral type",
+			    i + 1, fndecl);
 		return false;
 	      }
 	  if (TREE_CODE (TREE_TYPE (args[2])) != POINTER_TYPE
 	      || !INTEGRAL_TYPE_P (TREE_TYPE (TREE_TYPE (args[2]))))
 	    {
-	      error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
-			"does not have pointer to integral type", fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (2),
+			  "argument 3 in call to function %qE "
+			  "does not have pointer to integral type",
+			  fndecl);
 	      return false;
 	    }
 	  else if (TREE_CODE (TREE_TYPE (TREE_TYPE (args[2]))) == ENUMERAL_TYPE)
 	    {
-	      error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
-			"has pointer to enumerated type", fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (2),
+			  "argument 3 in call to function %qE "
+			  "has pointer to enumerated type",
+			  fndecl);
 	      return false;
 	    }
 	  else if (TREE_CODE (TREE_TYPE (TREE_TYPE (args[2]))) == BOOLEAN_TYPE)
 	    {
-	      error_at (ARG_LOCATION (2), "argument 3 in call to function %qE "
-			"has pointer to boolean type", fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (2),
+			  "argument 3 in call to function %qE "
+			  "has pointer to boolean type",
+			  fndecl);
 	      return false;
 	    }
 	  else if (TYPE_READONLY (TREE_TYPE (TREE_TYPE (args[2]))))
 	    {
-	      error_at (ARG_LOCATION (2), "argument %u in call to function %qE "
-			"has pointer to %qs type (%qT)", 3, fndecl, "const",
-			TREE_TYPE (args[2]));
+	      if (complain)
+		error_at (ARG_LOCATION (2),
+			  "argument %u in call to function %qE "
+			  "has pointer to %qs type (%qT)",
+			  3, fndecl, "const", TREE_TYPE (args[2]));
 	      return false;
 	    }
 	  else if (TYPE_ATOMIC (TREE_TYPE (TREE_TYPE (args[2]))))
 	    {
-	      error_at (ARG_LOCATION (2), "argument %u in call to function %qE "
-			"has pointer to %qs type (%qT)", 3, fndecl,
-			"_Atomic", TREE_TYPE (args[2]));
+	      if (complain)
+		error_at (ARG_LOCATION (2),
+			  "argument %u in call to function %qE "
+			  "has pointer to %qs type (%qT)",
+			  3, fndecl, "_Atomic", TREE_TYPE (args[2]));
 	      return false;
 	    }
 	  return true;
@@ -6534,26 +6571,35 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
     case BUILT_IN_ADD_OVERFLOW_P:
     case BUILT_IN_SUB_OVERFLOW_P:
     case BUILT_IN_MUL_OVERFLOW_P:
-      if (builtin_function_validate_nargs (loc, fndecl, nargs, 3))
+      if (builtin_function_validate_nargs (loc, fndecl, nargs, 3, complain))
 	{
 	  unsigned i;
 	  for (i = 0; i < 3; i++)
 	    if (!INTEGRAL_TYPE_P (TREE_TYPE (args[i])))
 	      {
-		error_at (ARG_LOCATION (i), "argument %u in call to function "
-			  "%qE does not have integral type", i + 1, fndecl);
+		if (complain)
+		  error_at (ARG_LOCATION (i),
+			    "argument %u in call to function "
+			    "%qE does not have integral type",
+			    i + 1, fndecl);
 		return false;
 	      }
 	  if (TREE_CODE (TREE_TYPE (args[2])) == ENUMERAL_TYPE)
 	    {
-	      error_at (ARG_LOCATION (2), "argument %u in call to function "
-			"%qE has enumerated type", 3, fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (2),
+			  "argument %u in call to function "
+			  "%qE has enumerated type",
+			  3, fndecl);
 	      return false;
 	    }
 	  else if (TREE_CODE (TREE_TYPE (args[2])) == BOOLEAN_TYPE)
 	    {
-	      error_at (ARG_LOCATION (2), "argument %u in call to function "
-			"%qE has boolean type", 3, fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (2),
+			  "argument %u in call to function "
+			  "%qE has boolean type",
+			  3, fndecl);
 	      return false;
 	    }
 	  return true;
@@ -6561,32 +6607,42 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
       return false;
 
     case BUILT_IN_CLEAR_PADDING:
-      if (builtin_function_validate_nargs (loc, fndecl, nargs, 1))
+      if (builtin_function_validate_nargs (loc, fndecl, nargs, 1, complain))
 	{
 	  if (!POINTER_TYPE_P (TREE_TYPE (args[0])))
 	    {
-	      error_at (ARG_LOCATION (0), "argument %u in call to function "
-			"%qE does not have pointer type", 1, fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (0),
+			  "argument %u in call to function "
+			  "%qE does not have pointer type",
+			  1, fndecl);
 	      return false;
 	    }
 	  else if (!COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (args[0]))))
 	    {
-	      error_at (ARG_LOCATION (0), "argument %u in call to function "
-			"%qE points to incomplete type", 1, fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (0),
+			  "argument %u in call to function "
+			  "%qE points to incomplete type",
+			  1, fndecl);
 	      return false;
 	    }
 	  else if (TYPE_READONLY (TREE_TYPE (TREE_TYPE (args[0]))))
 	    {
-	      error_at (ARG_LOCATION (0), "argument %u in call to function %qE "
-			"has pointer to %qs type (%qT)", 1, fndecl, "const",
-			TREE_TYPE (args[0]));
+	      if (complain)
+		error_at (ARG_LOCATION (0),
+			  "argument %u in call to function %qE "
+			  "has pointer to %qs type (%qT)",
+			  1, fndecl, "const", TREE_TYPE (args[0]));
 	      return false;
 	    }
 	  else if (TYPE_ATOMIC (TREE_TYPE (TREE_TYPE (args[0]))))
 	    {
-	      error_at (ARG_LOCATION (0), "argument %u in call to function %qE "
-			"has pointer to %qs type (%qT)", 1, fndecl,
-			"_Atomic", TREE_TYPE (args[0]));
+	      if (complain)
+		error_at (ARG_LOCATION (0),
+			  "argument %u in call to function %qE "
+			  "has pointer to %qs type (%qT)",
+			  1, fndecl, "_Atomic", TREE_TYPE (args[0]));
 	      return false;
 	    }
 	  return true;
@@ -6605,8 +6661,11 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
 	{
 	  if (!INTEGRAL_TYPE_P (TREE_TYPE (args[1])))
 	    {
-	      error_at (ARG_LOCATION (1), "argument %u in call to function "
-			"%qE does not have integral type", 2, fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (1),
+			  "argument %u in call to function "
+			  "%qE does not have integral type",
+			  2, fndecl);
 	      return false;
 	    }
 	  if ((TYPE_PRECISION (TREE_TYPE (args[1]))
@@ -6615,30 +6674,43 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
 		  == TYPE_PRECISION (integer_type_node)
 		  && TYPE_UNSIGNED (TREE_TYPE (args[1]))))
 	    {
-	      error_at (ARG_LOCATION (1), "argument %u in call to function "
-			"%qE does not have %<int%> type", 2, fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (1),
+			  "argument %u in call to function "
+			  "%qE does not have %<int%> type",
+			  2, fndecl);
 	      return false;
 	    }
 	}
-      else if (!builtin_function_validate_nargs (loc, fndecl, nargs, 1))
+      else if (!builtin_function_validate_nargs (loc, fndecl, nargs, 1,
+						 complain))
 	return false;
 
       if (!INTEGRAL_TYPE_P (TREE_TYPE (args[0])))
 	{
-	  error_at (ARG_LOCATION (0), "argument %u in call to function "
-		    "%qE does not have integral type", 1, fndecl);
+	  if (complain)
+	    error_at (ARG_LOCATION (0),
+		      "argument %u in call to function "
+		      "%qE does not have integral type",
+		      1, fndecl);
 	  return false;
 	}
       if (TREE_CODE (TREE_TYPE (args[0])) == ENUMERAL_TYPE)
 	{
-	  error_at (ARG_LOCATION (0), "argument %u in call to function "
-		    "%qE has enumerated type", 1, fndecl);
+	  if (complain)
+	    error_at (ARG_LOCATION (0),
+		      "argument %u in call to function "
+		      "%qE has enumerated type",
+		      1, fndecl);
 	  return false;
 	}
       if (TREE_CODE (TREE_TYPE (args[0])) == BOOLEAN_TYPE)
 	{
-	  error_at (ARG_LOCATION (0), "argument %u in call to function "
-		    "%qE has boolean type", 1, fndecl);
+	  if (complain)
+	    error_at (ARG_LOCATION (0),
+		      "argument %u in call to function "
+		      "%qE has boolean type",
+		      1, fndecl);
 	  return false;
 	}
       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FFSG
@@ -6646,15 +6718,21 @@ check_builtin_function_arguments (location_t loc, vec<location_t> arg_loc,
 	{
 	  if (TYPE_UNSIGNED (TREE_TYPE (args[0])))
 	    {
-	      error_at (ARG_LOCATION (0), "argument 1 in call to function "
-			"%qE has unsigned type", fndecl);
+	      if (complain)
+		error_at (ARG_LOCATION (0),
+			  "argument 1 in call to function "
+			  "%qE has unsigned type",
+			  fndecl);
 	      return false;
 	    }
 	}
       else if (!TYPE_UNSIGNED (TREE_TYPE (args[0])))
 	{
-	  error_at (ARG_LOCATION (0), "argument 1 in call to function "
-		    "%qE has signed type", fndecl);
+	  if (complain)
+	    error_at (ARG_LOCATION (0),
+		      "argument 1 in call to function "
+		      "%qE has signed type",
+		      fndecl);
 	  return false;
 	}
       return true;
@@ -7235,7 +7313,8 @@ builtin_type_for_size (int size, bool unsignedp)
    the size is too large; 0 if the argument type is a pointer or the
    size if it is integral.  */
 static enum built_in_function
-speculation_safe_value_resolve_call (tree function, vec<tree, va_gc> *params)
+speculation_safe_value_resolve_call (tree function, vec<tree, va_gc> *params,
+				     bool complain)
 {
   /* Type of the argument.  */
   tree type;
@@ -7243,7 +7322,8 @@ speculation_safe_value_resolve_call (tree function, vec<tree, va_gc> *params)
 
   if (vec_safe_is_empty (params))
     {
-      error ("too few arguments to function %qE", function);
+      if (complain)
+	error ("too few arguments to function %qE", function);
       return BUILT_IN_NONE;
     }
 
@@ -7272,7 +7352,7 @@ speculation_safe_value_resolve_call (tree function, vec<tree, va_gc> *params)
  incompatible:
   /* Issue the diagnostic only if the argument is valid, otherwise
      it would be redundant at best and could be misleading.  */
-  if (type != error_mark_node)
+  if (type != error_mark_node && complain)
     error ("operand type %qT is incompatible with argument %d of %qE",
 	   type, 1, function);
 
@@ -7284,19 +7364,21 @@ speculation_safe_value_resolve_call (tree function, vec<tree, va_gc> *params)
    argument, if present, must be type compatible with the first.  */
 static bool
 speculation_safe_value_resolve_params (location_t loc, tree orig_function,
-				       vec<tree, va_gc> *params)
+				       vec<tree, va_gc> *params, bool complain)
 {
   tree val;
 
   if (params->length () == 0)
     {
-      error_at (loc, "too few arguments to function %qE", orig_function);
+      if (complain)
+	error_at (loc, "too few arguments to function %qE", orig_function);
       return false;
     }
 
   else if (params->length () > 2)
     {
-      error_at (loc, "too many arguments to function %qE", orig_function);
+      if (complain)
+	error_at (loc, "too many arguments to function %qE", orig_function);
       return false;
     }
 
@@ -7306,9 +7388,9 @@ speculation_safe_value_resolve_params (location_t loc, tree orig_function,
   if (!(TREE_CODE (TREE_TYPE (val)) == POINTER_TYPE
 	|| TREE_CODE (TREE_TYPE (val)) == INTEGER_TYPE))
     {
-      error_at (loc,
-		"expecting argument of type pointer or of type integer "
-		"for argument 1");
+      if (complain)
+	error_at (loc, "expecting argument of type pointer or of type integer "
+		       "for argument 1");
       return false;
     }
   (*params)[0] = val;
@@ -7323,7 +7405,8 @@ speculation_safe_value_resolve_params (location_t loc, tree orig_function,
       if (!(TREE_TYPE (val) == TREE_TYPE (val2)
 	    || useless_type_conversion_p (TREE_TYPE (val), TREE_TYPE (val2))))
 	{
-	  error_at (loc, "both arguments must be compatible");
+	  if (complain)
+	    error_at (loc, "both arguments must be compatible");
 	  return false;
 	}
       (*params)[1] = val2;
@@ -7359,7 +7442,7 @@ speculation_safe_value_resolve_return (tree first_param, tree result)
 
 static int
 sync_resolve_size (tree function, vec<tree, va_gc> *params, bool fetch,
-		   bool orig_format)
+		   bool orig_format, bool complain)
 {
   /* Type of the argument.  */
   tree argtype;
@@ -7369,7 +7452,8 @@ sync_resolve_size (tree function, vec<tree, va_gc> *params, bool fetch,
 
   if (vec_safe_is_empty (params))
     {
-      error ("too few arguments to function %qE", function);
+      if (complain)
+	error ("too few arguments to function %qE", function);
       return 0;
     }
 
@@ -7410,7 +7494,7 @@ sync_resolve_size (tree function, vec<tree, va_gc> *params, bool fetch,
  incompatible:
   /* Issue the diagnostic only if the argument is valid, otherwise
      it would be redundant at best and could be misleading.  */
-  if (argtype != error_mark_node)
+  if (argtype != error_mark_node && complain)
     error ("operand type %qT is incompatible with argument %d of %qE",
 	   argtype, 1, function);
   return 0;
@@ -7423,7 +7507,7 @@ sync_resolve_size (tree function, vec<tree, va_gc> *params, bool fetch,
 
 static bool
 sync_resolve_params (location_t loc, tree orig_function, tree function,
-		     vec<tree, va_gc> *params, bool orig_format)
+		     vec<tree, va_gc> *params, bool orig_format, bool complain)
 {
   function_args_iterator iter;
   tree ptype;
@@ -7452,7 +7536,8 @@ sync_resolve_params (location_t loc, tree orig_function, tree function,
       ++parmnum;
       if (params->length () <= parmnum)
 	{
-	  error_at (loc, "too few arguments to function %qE", orig_function);
+	  if (complain)
+	    error_at (loc, "too few arguments to function %qE", orig_function);
 	  return false;
 	}
 
@@ -7478,7 +7563,8 @@ sync_resolve_params (location_t loc, tree orig_function, tree function,
   /* __atomic routines are not variadic.  */
   if (!orig_format && params->length () != parmnum + 1)
     {
-      error_at (loc, "too many arguments to function %qE", orig_function);
+      if (complain)
+	error_at (loc, "too many arguments to function %qE", orig_function);
       return false;
     }
 
@@ -7515,7 +7601,7 @@ sync_resolve_return (tree first_param, tree result, bool orig_format)
 
 static int
 get_atomic_generic_size (location_t loc, tree function,
-			 vec<tree, va_gc> *params)
+			 vec<tree, va_gc> *params, bool complain)
 {
   unsigned int n_param;
   unsigned int n_model;
@@ -7553,7 +7639,9 @@ get_atomic_generic_size (location_t loc, tree function,
 
   if (vec_safe_length (params) != n_param)
     {
-      error_at (loc, "incorrect number of arguments to function %qE", function);
+      if (complain)
+	error_at (loc, "incorrect number of arguments to function %qE",
+		  function);
       return 0;
     }
 
@@ -7567,24 +7655,27 @@ get_atomic_generic_size (location_t loc, tree function,
     }
   if (TREE_CODE (type_0) != POINTER_TYPE || VOID_TYPE_P (TREE_TYPE (type_0)))
     {
-      error_at (loc, "argument 1 of %qE must be a non-void pointer type",
-		function);
+      if (complain)
+	error_at (loc, "argument 1 of %qE must be a non-void pointer type",
+		  function);
       return 0;
     }
 
   if (!COMPLETE_TYPE_P (TREE_TYPE (type_0)))
     {
-      error_at (loc, "argument 1 of %qE must be a pointer to a complete type",
-		function);
+      if (complain)
+	error_at (loc, "argument 1 of %qE must be a pointer to a complete type",
+		  function);
       return 0;
     }
 
   /* Types must be compile time constant sizes. */
   if (!tree_fits_uhwi_p ((TYPE_SIZE_UNIT (TREE_TYPE (type_0)))))
     {
-      error_at (loc, 
-		"argument 1 of %qE must be a pointer to a constant size type",
-		function);
+      if (complain)
+	error_at (loc,
+		  "argument 1 of %qE must be a pointer to a constant size type",
+		  function);
       return 0;
     }
 
@@ -7593,9 +7684,10 @@ get_atomic_generic_size (location_t loc, tree function,
   /* Zero size objects are not allowed.  */
   if (size_0 == 0)
     {
-      error_at (loc, 
-		"argument 1 of %qE must be a pointer to a nonzero size object",
-		function);
+      if (complain)
+	error_at (
+	  loc, "argument 1 of %qE must be a pointer to a nonzero size object",
+	  function);
       return 0;
     }
 
@@ -7615,30 +7707,38 @@ get_atomic_generic_size (location_t loc, tree function,
 	}
       if (!POINTER_TYPE_P (type))
 	{
-	  error_at (loc, "argument %d of %qE must be a pointer type", x + 1,
-		    function);
+	  if (complain)
+	    error_at (loc, "argument %d of %qE must be a pointer type", x + 1,
+		      function);
 	  return 0;
 	}
       else if (TYPE_SIZE_UNIT (TREE_TYPE (type))
 	       && TREE_CODE ((TYPE_SIZE_UNIT (TREE_TYPE (type))))
 		  != INTEGER_CST)
 	{
-	  error_at (loc, "argument %d of %qE must be a pointer to a constant "
-		    "size type", x + 1, function);
+	  if (complain)
+	    error_at (loc,
+		      "argument %d of %qE must be a pointer to a constant "
+		      "size type",
+		      x + 1, function);
 	  return 0;
 	}
       else if (FUNCTION_POINTER_TYPE_P (type))
 	{
-	  error_at (loc, "argument %d of %qE must not be a pointer to a "
-		    "function", x + 1, function);
+	  if (complain)
+	    error_at (loc,
+		      "argument %d of %qE must not be a pointer to a "
+		      "function",
+		      x + 1, function);
 	  return 0;
 	}
       tree type_size = TYPE_SIZE_UNIT (TREE_TYPE (type));
       size = type_size ? tree_to_uhwi (type_size) : 0;
       if (size != size_0)
 	{
-	  error_at (loc, "size mismatch in argument %d of %qE", x + 1,
-		    function);
+	  if (complain)
+	    error_at (loc, "size mismatch in argument %d of %qE", x + 1,
+		      function);
 	  return 0;
 	}
 
@@ -7650,8 +7750,11 @@ get_atomic_generic_size (location_t loc, tree function,
 	  {
 	    if (c_dialect_cxx ())
 	      {
-		error_at (loc, "argument %d of %qE must not be a pointer to "
-			  "a %<const%> type", x + 1, function);
+		if (complain)
+		  error_at (loc,
+			    "argument %d of %qE must not be a pointer to "
+			    "a %<const%> type",
+			    x + 1, function);
 		return 0;
 	      }
 	    else
@@ -7664,8 +7767,11 @@ get_atomic_generic_size (location_t loc, tree function,
 	  {
 	    if (c_dialect_cxx ())
 	      {
-		error_at (loc, "argument %d of %qE must not be a pointer to "
-			  "a %<volatile%> type", x + 1, function);
+		if (complain)
+		  error_at (loc,
+			    "argument %d of %qE must not be a pointer to "
+			    "a %<volatile%> type",
+			    x + 1, function);
 		return 0;
 	      }
 	    else
@@ -7682,8 +7788,9 @@ get_atomic_generic_size (location_t loc, tree function,
       tree p = (*params)[x];
       if (!INTEGRAL_TYPE_P (TREE_TYPE (p)))
 	{
-	  error_at (loc, "non-integer memory model argument %d of %qE", x + 1,
-		    function);
+	  if (complain)
+	    error_at (loc, "non-integer memory model argument %d of %qE", x + 1,
+		      function);
 	  return 0;
 	}
       p = fold_for_warn (p);
@@ -7773,12 +7880,13 @@ atomic_size_supported_p (int n)
    FALSE is returned if processing for the _N variation is required, and 
    NEW_RETURN is set to the return value the result is copied into.  */
 static bool
-resolve_overloaded_atomic_exchange (location_t loc, tree function, 
-				    vec<tree, va_gc> *params, tree *new_return)
+resolve_overloaded_atomic_exchange (location_t loc, tree function,
+				    vec<tree, va_gc> *params, tree *new_return,
+				    bool complain)
 {	
   tree p0, p1, p2, p3;
   tree I_type, I_type_ptr;
-  int n = get_atomic_generic_size (loc, function, params);
+  int n = get_atomic_generic_size (loc, function, params, complain);
 
   /* Size of 0 is an error condition.  */
   if (n == 0)
@@ -7842,13 +7950,13 @@ resolve_overloaded_atomic_exchange (location_t loc, tree function,
    FALSE is returned if processing for the _N variation is required.  */
 
 static bool
-resolve_overloaded_atomic_compare_exchange (location_t loc, tree function, 
-					    vec<tree, va_gc> *params, 
-					    tree *new_return)
+resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
+					    vec<tree, va_gc> *params,
+					    tree *new_return, bool complain)
 {	
   tree p0, p1, p2;
   tree I_type, I_type_ptr;
-  int n = get_atomic_generic_size (loc, function, params);
+  int n = get_atomic_generic_size (loc, function, params, complain);
 
   /* Size of 0 is an error condition.  */
   if (n == 0)
@@ -7924,12 +8032,13 @@ resolve_overloaded_atomic_compare_exchange (location_t loc, tree function,
    NEW_RETURN is set to the return value the result is copied into.  */
 
 static bool
-resolve_overloaded_atomic_load (location_t loc, tree function, 
-				vec<tree, va_gc> *params, tree *new_return)
+resolve_overloaded_atomic_load (location_t loc, tree function,
+				vec<tree, va_gc> *params, tree *new_return,
+				bool complain)
 {	
   tree p0, p1, p2;
   tree I_type, I_type_ptr;
-  int n = get_atomic_generic_size (loc, function, params);
+  int n = get_atomic_generic_size (loc, function, params, complain);
 
   /* Size of 0 is an error condition.  */
   if (n == 0)
@@ -7984,12 +8093,13 @@ resolve_overloaded_atomic_load (location_t loc, tree function,
    NEW_RETURN is set to the return value the result is copied into.  */
 
 static bool
-resolve_overloaded_atomic_store (location_t loc, tree function, 
-				 vec<tree, va_gc> *params, tree *new_return)
+resolve_overloaded_atomic_store (location_t loc, tree function,
+				 vec<tree, va_gc> *params, tree *new_return,
+				 bool complain)
 {	
   tree p0, p1;
   tree I_type, I_type_ptr;
-  int n = get_atomic_generic_size (loc, function, params);
+  int n = get_atomic_generic_size (loc, function, params, complain);
 
   /* Size of 0 is an error condition.  */
   if (n == 0)
@@ -8269,7 +8379,7 @@ atomic_bitint_fetch_using_cas_loop (location_t loc,
 
 tree
 resolve_overloaded_builtin (location_t loc, tree function,
-			    vec<tree, va_gc> *params)
+			    vec<tree, va_gc> *params, bool complain)
 {
   /* Is function one of the _FETCH_OP_ or _OP_FETCH_ built-ins?
      Those are not valid to call with a pointer to _Bool (or C++ bool)
@@ -8284,7 +8394,8 @@ resolve_overloaded_builtin (location_t loc, tree function,
       break;
     case BUILT_IN_MD:
       if (targetm.resolve_overloaded_builtin)
-	return targetm.resolve_overloaded_builtin (loc, function, params);
+	return targetm.resolve_overloaded_builtin (loc, function, params,
+						   complain);
       else
 	return NULL_TREE;
     default:
@@ -8299,13 +8410,14 @@ resolve_overloaded_builtin (location_t loc, tree function,
       {
 	tree new_function, first_param, result;
 	enum built_in_function fncode
-	  = speculation_safe_value_resolve_call (function, params);
+	  = speculation_safe_value_resolve_call (function, params, complain);
 
 	if (fncode == BUILT_IN_NONE)
 	  return error_mark_node;
 
 	first_param = (*params)[0];
-	if (!speculation_safe_value_resolve_params (loc, function, params))
+	if (!speculation_safe_value_resolve_params (loc, function, params,
+						    complain))
 	  return error_mark_node;
 
 	if (targetm.have_speculation_safe_value (true))
@@ -8324,6 +8436,11 @@ resolve_overloaded_builtin (location_t loc, tree function,
 	    /* This target doesn't have, or doesn't need, active mitigation
 	       against incorrect speculative execution.  Simply return the
 	       first parameter to the builtin.  */
+	    /* N.b. emit the warning whether or not we're given
+	       `complain`, since that argument is for things like
+	       SFINAE whereas the situation we're warning on could not be
+	       picked up by that (because we're not returning
+	       `error_mark_node`).  */
 	    if (!targetm.have_speculation_safe_value (false))
 	      /* The user has invoked __builtin_speculation_safe_value
 		 even though __HAVE_SPECULATION_SAFE_VALUE is not
@@ -8356,41 +8473,41 @@ resolve_overloaded_builtin (location_t loc, tree function,
 	  {
 	  case BUILT_IN_ATOMIC_EXCHANGE:
 	    {
-	      if (resolve_overloaded_atomic_exchange (loc, function, params,
-						      &new_return))
-		return new_return;
-	      /* Change to the _N variant.  */
-	      orig_code = BUILT_IN_ATOMIC_EXCHANGE_N;
-	      break;
+	    if (resolve_overloaded_atomic_exchange (loc, function, params,
+						    &new_return, complain))
+	      return new_return;
+	    /* Change to the _N variant.  */
+	    orig_code = BUILT_IN_ATOMIC_EXCHANGE_N;
+	    break;
 	    }
 
 	  case BUILT_IN_ATOMIC_COMPARE_EXCHANGE:
 	    {
-	      if (resolve_overloaded_atomic_compare_exchange (loc, function,
-							      params,
-							      &new_return))
-		return new_return;
-	      /* Change to the _N variant.  */
-	      orig_code = BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N;
-	      break;
+	    if (resolve_overloaded_atomic_compare_exchange (loc, function,
+							    params, &new_return,
+							    complain))
+	      return new_return;
+	    /* Change to the _N variant.  */
+	    orig_code = BUILT_IN_ATOMIC_COMPARE_EXCHANGE_N;
+	    break;
 	    }
 	  case BUILT_IN_ATOMIC_LOAD:
 	    {
-	      if (resolve_overloaded_atomic_load (loc, function, params,
-						  &new_return))
-		return new_return;
-	      /* Change to the _N variant.  */
-	      orig_code = BUILT_IN_ATOMIC_LOAD_N;
-	      break;
+	    if (resolve_overloaded_atomic_load (loc, function, params,
+						&new_return, complain))
+	      return new_return;
+	    /* Change to the _N variant.  */
+	    orig_code = BUILT_IN_ATOMIC_LOAD_N;
+	    break;
 	    }
 	  case BUILT_IN_ATOMIC_STORE:
 	    {
-	      if (resolve_overloaded_atomic_store (loc, function, params,
-						   &new_return))
-		return new_return;
-	      /* Change to the _N variant.  */
-	      orig_code = BUILT_IN_ATOMIC_STORE_N;
-	      break;
+	    if (resolve_overloaded_atomic_store (loc, function, params,
+						 &new_return, complain))
+	      return new_return;
+	    /* Change to the _N variant.  */
+	    orig_code = BUILT_IN_ATOMIC_STORE_N;
+	    break;
 	    }
 	  default:
 	    gcc_unreachable ();
@@ -8442,7 +8559,8 @@ resolve_overloaded_builtin (location_t loc, tree function,
 		      && orig_code != BUILT_IN_SYNC_LOCK_TEST_AND_SET_N
 		      && orig_code != BUILT_IN_SYNC_LOCK_RELEASE_N);
 
-	int n = sync_resolve_size (function, params, fetch_op, orig_format);
+	int n = sync_resolve_size (function, params, fetch_op, orig_format,
+				   complain);
 	tree new_function, first_param, result;
 	enum built_in_function fncode;
 
@@ -8450,13 +8568,24 @@ resolve_overloaded_builtin (location_t loc, tree function,
 	  return error_mark_node;
 
 	if (n == -1)
-	  return atomic_bitint_fetch_using_cas_loop (loc, orig_code,
-						     function, params);
+	  {
+	    /* complain is related to SFINAE context.
+	       _BitInt is not defined in C++, hence can't enter this clause
+	       with complain unset.  Even if at the abstraction level
+	       this complain is unset that still makes sense (whether
+	       this function should report an error or not if anything is
+	       wrong).
+	       Since can't test avoiding an error when this value is false not
+	       writing the code and instead asserting value is not set.  */
+	    gcc_assert (complain);
+	    return atomic_bitint_fetch_using_cas_loop (loc, orig_code, function,
+						       params);
+	  }
 
 	fncode = (enum built_in_function)((int)orig_code + exact_log2 (n) + 1);
 	new_function = builtin_decl_explicit (fncode);
 	if (!sync_resolve_params (loc, function, new_function, params,
-				  orig_format))
+				  orig_format, complain))
 	  return error_mark_node;
 
 	first_param = (*params)[0];
diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index 027f077d51b..d2bbe9d4c20 100644
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -857,8 +857,9 @@ extern void check_function_arguments_recurse (void (*)
 					      void *, tree,
 					      unsigned HOST_WIDE_INT,
 					      opt_code);
-extern bool check_builtin_function_arguments (location_t, vec<location_t>,
-					      tree, tree, int, tree *);
+extern bool
+check_builtin_function_arguments (location_t, vec<location_t>, tree, tree, int,
+				  tree *, bool = true);
 extern void check_function_format (const_tree, tree, int, tree *,
 				   vec<location_t> *,
 				   bool (*comp_types) (tree, tree));
@@ -1103,7 +1104,8 @@ extern tree build_function_call_vec (location_t, vec<location_t>, tree,
 				     vec<tree, va_gc> *, vec<tree, va_gc> *,
 				     tree = NULL_TREE);
 
-extern tree resolve_overloaded_builtin (location_t, tree, vec<tree, va_gc> *);
+extern tree
+resolve_overloaded_builtin (location_t, tree, vec<tree, va_gc> *, bool = true);
 
 extern tree finish_label_address_expr (tree, location_t);
 
diff --git a/gcc/config/aarch64/aarch64-c.cc b/gcc/config/aarch64/aarch64-c.cc
index f9b9e379375..ddf5a6c453c 100644
--- a/gcc/config/aarch64/aarch64-c.cc
+++ b/gcc/config/aarch64/aarch64-c.cc
@@ -365,8 +365,8 @@ aarch64_pragma_aarch64 (cpp_reader *)
 
 /* Implement TARGET_RESOLVE_OVERLOADED_BUILTIN.  */
 static tree
-aarch64_resolve_overloaded_builtin (unsigned int uncast_location,
-				    tree fndecl, void *uncast_arglist)
+aarch64_resolve_overloaded_builtin (unsigned int uncast_location, tree fndecl,
+				    void *uncast_arglist, bool)
 {
   vec<tree, va_gc> empty = {};
   location_t location = (location_t) uncast_location;
@@ -396,7 +396,7 @@ aarch64_resolve_overloaded_builtin (unsigned int uncast_location,
 static bool
 aarch64_check_builtin_call (location_t loc, vec<location_t> arg_loc,
 			    tree fndecl, tree orig_fndecl,
-			    unsigned int nargs, tree *args)
+			    unsigned int nargs, tree *args, bool)
 {
   unsigned int code = DECL_MD_FUNCTION_CODE (fndecl);
   unsigned int subcode = code >> AARCH64_BUILTIN_SHIFT;
diff --git a/gcc/config/arm/arm-builtins.cc b/gcc/config/arm/arm-builtins.cc
index 74cea8900b4..ee0f1c551ca 100644
--- a/gcc/config/arm/arm-builtins.cc
+++ b/gcc/config/arm/arm-builtins.cc
@@ -4211,7 +4211,7 @@ arm_general_check_builtin_call (unsigned int code)
 bool
 arm_check_builtin_call (location_t loc, vec<location_t> arg_loc,
 			tree fndecl, tree orig_fndecl,
-			unsigned int nargs, tree *args)
+			unsigned int nargs, tree *args, bool)
 {
   unsigned int code = DECL_MD_FUNCTION_CODE (fndecl);
   unsigned int subcode = code >> ARM_BUILTIN_SHIFT;
diff --git a/gcc/config/arm/arm-c.cc b/gcc/config/arm/arm-c.cc
index 6e10262b067..74006752aff 100644
--- a/gcc/config/arm/arm-c.cc
+++ b/gcc/config/arm/arm-c.cc
@@ -163,7 +163,7 @@ arm_pragma_arm (cpp_reader *)
 /* Implement TARGET_RESOLVE_OVERLOADED_BUILTIN.  */
 tree
 arm_resolve_overloaded_builtin (location_t loc, tree fndecl,
-				void *uncast_arglist)
+				void *uncast_arglist, bool)
 {
   enum resolver_ident resolver = arm_describe_resolver (fndecl);
   if (resolver == arm_cde_resolver)
diff --git a/gcc/config/arm/arm-protos.h b/gcc/config/arm/arm-protos.h
index b694589cab4..7f0f20542d6 100644
--- a/gcc/config/arm/arm-protos.h
+++ b/gcc/config/arm/arm-protos.h
@@ -32,7 +32,7 @@ extern int use_return_insn (int, rtx);
 extern bool use_simple_return_p (void);
 extern enum reg_class arm_regno_class (int);
 extern bool arm_check_builtin_call (location_t , vec<location_t> , tree,
-				    tree, unsigned int, tree *);
+				    tree, unsigned int, tree *, bool);
 extern void arm_load_pic_register (unsigned long, rtx);
 extern int arm_volatile_func (void);
 extern void arm_expand_prologue (void);
diff --git a/gcc/config/avr/avr-c.cc b/gcc/config/avr/avr-c.cc
index 81c91c38363..34531b40a9d 100644
--- a/gcc/config/avr/avr-c.cc
+++ b/gcc/config/avr/avr-c.cc
@@ -48,7 +48,8 @@ enum avr_builtin_id
 /* Implement `TARGET_RESOLVE_OVERLOADED_PLUGIN'.  */
 
 static tree
-avr_resolve_overloaded_builtin (unsigned int iloc, tree fndecl, void *vargs)
+avr_resolve_overloaded_builtin (unsigned int iloc, tree fndecl, void *vargs,
+				bool)
 {
   tree type0, type1, fold = NULL_TREE;
   avr_builtin_id id = AVR_BUILTIN_COUNT;
diff --git a/gcc/config/riscv/riscv-c.cc b/gcc/config/riscv/riscv-c.cc
index 7e9c478e97b..34cc8cd96a7 100644
--- a/gcc/config/riscv/riscv-c.cc
+++ b/gcc/config/riscv/riscv-c.cc
@@ -289,7 +289,7 @@ riscv_pragma_intrinsic (cpp_reader *)
 /* Implement TARGET_CHECK_BUILTIN_CALL.  */
 static bool
 riscv_check_builtin_call (location_t loc, vec<location_t> arg_loc, tree fndecl,
-			  tree, unsigned int nargs, tree *args)
+			  tree, unsigned int nargs, tree *args, bool)
 {
   unsigned int code = DECL_MD_FUNCTION_CODE (fndecl);
   unsigned int subcode = code >> RISCV_BUILTIN_SHIFT;
@@ -308,7 +308,7 @@ riscv_check_builtin_call (location_t loc, vec<location_t> arg_loc, tree fndecl,
 /* Implement TARGET_RESOLVE_OVERLOADED_BUILTIN.  */
 static tree
 riscv_resolve_overloaded_builtin (unsigned int uncast_location, tree fndecl,
-				  void *uncast_arglist)
+				  void *uncast_arglist, bool)
 {
   vec<tree, va_gc> empty = {};
   location_t loc = (location_t) uncast_location;
diff --git a/gcc/config/rs6000/rs6000-c.cc b/gcc/config/rs6000/rs6000-c.cc
index 04882c396bf..c8369b51b84 100644
--- a/gcc/config/rs6000/rs6000-c.cc
+++ b/gcc/config/rs6000/rs6000-c.cc
@@ -1680,7 +1680,7 @@ find_instance (bool *unsupported_builtin, int *instance,
 
 tree
 altivec_resolve_overloaded_builtin (location_t loc, tree fndecl,
-				    void *passed_arglist)
+				    void *passed_arglist, bool)
 {
   rs6000_gen_builtins fcode
     = (rs6000_gen_builtins) DECL_MD_FUNCTION_CODE (fndecl);
diff --git a/gcc/config/rs6000/rs6000-protos.h b/gcc/config/rs6000/rs6000-protos.h
index b40557a8557..3328a9ebe14 100644
--- a/gcc/config/rs6000/rs6000-protos.h
+++ b/gcc/config/rs6000/rs6000-protos.h
@@ -266,7 +266,8 @@ extern unsigned int rs6000_special_round_type_align (tree, unsigned int,
 						     unsigned int);
 extern unsigned int darwin_rs6000_special_round_type_align (tree, unsigned int,
 							    unsigned int);
-extern tree altivec_resolve_overloaded_builtin (location_t, tree, void *);
+extern tree
+altivec_resolve_overloaded_builtin (location_t, tree, void *, bool = true);
 extern rtx rs6000_libcall_value (machine_mode);
 extern rtx rs6000_va_arg (tree, tree);
 extern int function_ok_for_sibcall (tree);
diff --git a/gcc/config/s390/s390-c.cc b/gcc/config/s390/s390-c.cc
index 4521a86f048..9c833547d1e 100644
--- a/gcc/config/s390/s390-c.cc
+++ b/gcc/config/s390/s390-c.cc
@@ -884,9 +884,8 @@ s390_vec_n_elem (tree fndecl)
 /* Return a tree expression for a call to the overloaded builtin
    function OB_FNDECL at LOC with arguments PASSED_ARGLIST.  */
 tree
-s390_resolve_overloaded_builtin (location_t loc,
-				 tree ob_fndecl,
-				 void *passed_arglist)
+s390_resolve_overloaded_builtin (location_t loc, tree ob_fndecl,
+				 void *passed_arglist, bool)
 {
   vec<tree, va_gc> *arglist = static_cast<vec<tree, va_gc> *> (passed_arglist);
   unsigned int in_args_num = vec_safe_length (arglist);
diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index 309ab01d12d..aa829704a28 100644
--- a/gcc/cp/call.cc
+++ b/gcc/cp/call.cc
@@ -11168,7 +11168,8 @@ build_cxx_call (tree fn, int nargs, tree *argarray,
 	argarray[i] = maybe_constant_value (argarray[i]);
 
       if (!check_builtin_function_arguments (EXPR_LOCATION (fn), vNULL, fndecl,
-					     orig_fndecl, nargs, argarray))
+					     orig_fndecl, nargs, argarray,
+					     complain & tf_error))
 	return error_mark_node;
       else if (fndecl_built_in_p (fndecl, BUILT_IN_CLEAR_PADDING))
 	{
diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc
index 0370d81de01..33ff7a90e6e 100644
--- a/gcc/cp/semantics.cc
+++ b/gcc/cp/semantics.cc
@@ -3195,7 +3195,8 @@ finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,
       if (TREE_CODE (fn) == FUNCTION_DECL
 	  && (DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
 	      || DECL_BUILT_IN_CLASS (fn) == BUILT_IN_MD))
-	result = resolve_overloaded_builtin (input_location, fn, *args);
+	result = resolve_overloaded_builtin (input_location, fn, *args,
+					     complain & tf_error);
 
       if (!result)
 	{
diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
index 4deb3d2c283..33a361880bc 100644
--- a/gcc/doc/tm.texi
+++ b/gcc/doc/tm.texi
@@ -12108,7 +12108,7 @@ ignored.  This function should return the result of the call to the
 built-in function.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_RESOLVE_OVERLOADED_BUILTIN (unsigned int @var{loc}, tree @var{fndecl}, void *@var{arglist})
+@deftypefn {Target Hook} tree TARGET_RESOLVE_OVERLOADED_BUILTIN (unsigned int @var{loc}, tree @var{fndecl}, void *@var{arglist}, bool @var{complain})
 Select a replacement for a machine specific built-in function that
 was set up by @samp{TARGET_INIT_BUILTINS}.  This is done
 @emph{before} regular type checking, and so allows the target to
@@ -12118,9 +12118,12 @@ arguments passed to the built-in function.  The result is a
 complete expression that implements the operation, usually
 another @code{CALL_EXPR}.
 @var{arglist} really has type @samp{VEC(tree,gc)*}
+@var{complain} is a boolean indicating whether invalid operations
+should emit errors.  This is set to @code{false} when the C++ templating
+context expects that errors should not be emitted (i.e. SFINAE).
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_CHECK_BUILTIN_CALL (location_t @var{loc}, vec<location_t> @var{arg_loc}, tree @var{fndecl}, tree @var{orig_fndecl}, unsigned int @var{nargs}, tree *@var{args})
+@deftypefn {Target Hook} bool TARGET_CHECK_BUILTIN_CALL (location_t @var{loc}, vec<location_t> @var{arg_loc}, tree @var{fndecl}, tree @var{orig_fndecl}, unsigned int @var{nargs}, tree *@var{args}, bool @var{complain})
 Perform semantic checking on a call to a machine-specific built-in
 function after its arguments have been constrained to the function
 signature.  Return true if the call is valid, otherwise report an error
@@ -12132,7 +12135,9 @@ but after the optional @code{TARGET_RESOLVE_OVERLOADED_BUILTIN}
 step is now to built-in function @var{fndecl}.  @var{loc} is the
 location of the call and @var{args} is an array of function arguments,
 of which there are @var{nargs}.  @var{arg_loc} specifies the location
-of each argument.
+of each argument.  @var{complain} is a boolean indicating whether invalid
+arguments should emitm errors.  This is set to @code{false} when the C++
+templating context expects that errors should not be emitted (i.e. SFINAE).
 @end deftypefn
 
 @deftypefn {Target Hook} tree TARGET_FOLD_BUILTIN (tree @var{fndecl}, int @var{n_args}, tree *@var{argp}, bool @var{ignore})
diff --git a/gcc/target.def b/gcc/target.def
index b3155010888..66c14dfc355 100644
--- a/gcc/target.def
+++ b/gcc/target.def
@@ -2496,8 +2496,11 @@ declaration of the built-in function.  @var{arglist} is the list of\n\
 arguments passed to the built-in function.  The result is a\n\
 complete expression that implements the operation, usually\n\
 another @code{CALL_EXPR}.\n\
-@var{arglist} really has type @samp{VEC(tree,gc)*}",
- tree, (unsigned int /*location_t*/ loc, tree fndecl, void *arglist), NULL)
+@var{arglist} really has type @samp{VEC(tree,gc)*}\n\
+@var{complain} is a boolean indicating whether invalid operations\n\
+should emit errors.  This is set to @code{false} when the C++ templating\n\
+context expects that errors should not be emitted (i.e. SFINAE).",
+ tree, (unsigned int /*location_t*/ loc, tree fndecl, void *arglist, bool complain), NULL)
 
 DEFHOOK
 (check_builtin_call,
@@ -2512,9 +2515,11 @@ but after the optional @code{TARGET_RESOLVE_OVERLOADED_BUILTIN}\n\
 step is now to built-in function @var{fndecl}.  @var{loc} is the\n\
 location of the call and @var{args} is an array of function arguments,\n\
 of which there are @var{nargs}.  @var{arg_loc} specifies the location\n\
-of each argument.",
+of each argument.  @var{complain} is a boolean indicating whether invalid\n\
+arguments should emitm errors.  This is set to @code{false} when the C++\n\
+templating context expects that errors should not be emitted (i.e. SFINAE).",
  bool, (location_t loc, vec<location_t> arg_loc, tree fndecl,
-	tree orig_fndecl, unsigned int nargs, tree *args),
+	tree orig_fndecl, unsigned int nargs, tree *args, bool complain),
  NULL)
 
 /* Fold a target-specific builtin to a tree valid for both GIMPLE
diff --git a/gcc/testsuite/g++.dg/template/builtin-atomic-overloads.def b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads.def
new file mode 100644
index 00000000000..6d6f9e52186
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads.def
@@ -0,0 +1,159 @@
+#include <type_traits>
+
+class X{};
+/* Want a zero-sized type in order to trigger one of the error messages.
+   Don't want the error message about creating a zero sized type.
+   However, *do* want to see any pedantic error messages coming from the rest
+   of the testcase.  */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+class Zero {
+    unsigned int trailing[0];
+};
+#pragma GCC diagnostic pop
+class Large { public: int arr[10]; };
+class Incomplete;
+
+/* N.b. we have to use std::remove_pointer_t<T> for a few of the cases below to
+   handle using `int *` as the type.
+   In turn the problem is:
+     1) __atomic_load_n (int *, int) is valid, so when having `int *` as the
+	type to operate on does not create something invalid (which is the
+	point of the NONPOINTER_PARAMS entry).
+     2) __atomic_store_n (int *, int *, int) is not correct w.r.t. types
+	according to the GCC manual (and indeed ends up casting the pointer VAL
+	into an integer before storing it into the location.
+	However this is a known behaviour (PR 69404) so we're just working
+	around that for the moment.
+     3) __atomic_exchange_n and __atomic_compare_exchange_n, and all the
+	__atomic_fetch_<op> functions are using std::remove_pointer_t for
+	essentially the same behaviour of discarding the types as
+        __atomic_store_n.  */
+
+#define ATOMIC_SFINAES                                                      \
+  SFINAE_TYPE_CHECK(load_n,                                                 \
+		     (std::declval<T*>(), int()),                           \
+		     (std::declval<std::remove_pointer_t<T>> (), int()))    \
+  SFINAE_TYPE_CHECK(load,                                                   \
+		     (std::declval<T*>(), std::declval<T *>(), int()),      \
+		     (std::declval<T> (), std::declval<T*>(), int()))       \
+  SFINAE_TYPE_CHECK(store_n,                                                \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(store,                                                  \
+		     (std::declval<T*>(), std::declval<T *>(), int()),      \
+		     (std::declval<T> (), std::declval<T*>(), int()))       \
+  SFINAE_TYPE_CHECK(exchange_n,                                             \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(exchange,                                               \
+		     (std::declval<T*>(), std::declval<T *>(),              \
+		      std::declval<T*>(), int()),                           \
+		     (std::declval<T> (), std::declval<T*>(),               \
+		      std::declval<T*>(), int()))                           \
+  SFINAE_TYPE_CHECK(compare_exchange_n,                                     \
+		     (std::declval<T*>(), std::declval<T *>(),              \
+		      std::declval<T> (), bool(), int(), int()),            \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T*>(),               \
+		      std::declval<T> (), bool(), int(), int()))            \
+  SFINAE_TYPE_CHECK(compare_exchange,                                       \
+		     (std::declval<T*>(), std::declval<T *>(),              \
+		      std::declval<T*>(), bool(), int(), int()),            \
+		     (std::declval<T> (), std::declval<T*>(),               \
+		      std::declval<T*>(), bool(), int(), int()))            \
+  SFINAE_TYPE_CHECK(add_fetch,                                              \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(fetch_add,                                              \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(sub_fetch,                                              \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(fetch_sub,                                              \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(and_fetch,                                              \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(fetch_and,                                              \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(xor_fetch,                                              \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(fetch_xor,                                              \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(or_fetch,                                               \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(fetch_or,                                               \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(nand_fetch,                                             \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))        \
+  SFINAE_TYPE_CHECK(fetch_nand,                                             \
+		     (std::declval<T*>(), std::declval<T>(), int()),        \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T>(), int()))
+
+ATOMIC_SFINAES
+
+#define FETCH_OP_ASSERTS(NAME) \
+  MAKE_ATOMIC_ASSERT(NAME, int *, true) \
+  MAKE_ATOMIC_ASSERT(NAME, float, false) \
+  MAKE_ATOMIC_ASSERT(NAME, int, true) \
+  MAKE_ATOMIC_ASSERT(NAME, bool,  false) \
+  MAKE_ATOMIC_ASSERT(NAME, X,  false) \
+  MAKE_ATOMIC_ASSERT(NAME, Zero,  false) \
+  MAKE_ATOMIC_ASSERT(NAME, Large,  false) \
+  MAKE_ATOMIC_ASSERT(NAME, Incomplete,  false) \
+  MAKE_ATOMIC_ASSERT(NAME, long, true)
+
+#define ATOMIC_FETCH_ASSERTS \
+  FETCH_OP_ASSERTS(add_fetch) \
+  FETCH_OP_ASSERTS(fetch_add) \
+  FETCH_OP_ASSERTS(sub_fetch) \
+  FETCH_OP_ASSERTS(fetch_sub) \
+  FETCH_OP_ASSERTS(and_fetch) \
+  FETCH_OP_ASSERTS(fetch_and) \
+  FETCH_OP_ASSERTS(xor_fetch) \
+  FETCH_OP_ASSERTS(fetch_xor) \
+  FETCH_OP_ASSERTS(or_fetch) \
+  FETCH_OP_ASSERTS(fetch_or) \
+  FETCH_OP_ASSERTS(nand_fetch) \
+  FETCH_OP_ASSERTS(fetch_nand)
+
+#define ATOMIC_GENERIC_ASSERTS(NAME) \
+  MAKE_ATOMIC_ASSERT(NAME##_n, int *, true) \
+  MAKE_ATOMIC_ASSERT(NAME##_n, int, true) \
+  MAKE_ATOMIC_ASSERT(NAME##_n, bool,  true) \
+  MAKE_ATOMIC_ASSERT(NAME##_n, X,  false) \
+  MAKE_ATOMIC_ASSERT(NAME##_n, Zero,  false) \
+  MAKE_ATOMIC_ASSERT(NAME##_n, Large,  false) \
+  MAKE_ATOMIC_ASSERT(NAME##_n, Incomplete,  false) \
+  MAKE_ATOMIC_ASSERT(NAME##_n, long, true) \
+  MAKE_ATOMIC_ASSERT(NAME##_n, float, false) \
+  MAKE_ATOMIC_ASSERT(NAME, int *, true) \
+  MAKE_ATOMIC_ASSERT(NAME, int, true) \
+  MAKE_ATOMIC_ASSERT(NAME, bool,  true) \
+  MAKE_ATOMIC_ASSERT(NAME, X,  true) \
+  MAKE_ATOMIC_ASSERT(NAME, Zero,  false) \
+  MAKE_ATOMIC_ASSERT(NAME, Large,  true) \
+  MAKE_ATOMIC_ASSERT(NAME, Incomplete,  false) \
+  MAKE_ATOMIC_ASSERT(NAME, float, true) \
+  MAKE_ATOMIC_ASSERT(NAME, long, true)
+
+
+#define ATOMIC_ASSERTS \
+  ATOMIC_FETCH_ASSERTS \
+  ATOMIC_GENERIC_ASSERTS(load) \
+  ATOMIC_GENERIC_ASSERTS(store) \
+  ATOMIC_GENERIC_ASSERTS(exchange) \
+  ATOMIC_GENERIC_ASSERTS(compare_exchange)
+
+int main() {
+    ATOMIC_ASSERTS
+    return 0;
+}
diff --git a/gcc/testsuite/g++.dg/template/builtin-atomic-overloads1.C b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads1.C
new file mode 100644
index 00000000000..b6b06c725f1
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads1.C
@@ -0,0 +1,24 @@
+/* Check that overloaded builtins can be used in templates with SFINAE.  */
+// { dg-do compile { target c++17 } }
+
+/* builtin-atomic-overloads{1,2,3,4,5}.C are focussed on checking various
+   properties of all the different atomic builtins.
+   builtin-atomic-overloads6.C is focussed on checking all error conditions in
+   the code ignoring which builtin we trigger them with.  */
+
+/* Checks performed here:
+   Correctly specified -- as long as the type is something that these builtins
+   can work on.  */
+#define SFINAE_TYPE_CHECK(NAME, PARAMS, NONPOINTER_PARAMS) \
+  template <typename T, typename = void> \
+  struct is_##NAME##_available : std::false_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME PARAMS) >> \
+    : std::true_type {};
+
+/* Success according to type argument.  */
+#define MAKE_ATOMIC_ASSERT(NAME, TYPE, SUCCESS) \
+  static_assert(is_##NAME##_available<TYPE>::value == SUCCESS);
+
+#include "builtin-atomic-overloads.def"
diff --git a/gcc/testsuite/g++.dg/template/builtin-atomic-overloads2.C b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads2.C
new file mode 100644
index 00000000000..72131f5cc2b
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads2.C
@@ -0,0 +1,18 @@
+/* Check that overloaded builtins can be used in templates with SFINAE.  */
+// { dg-do compile { target c++17 } }
+
+/* Checks performed here:
+   Parameters without a pointer where it should be.  */
+#define SFINAE_TYPE_CHECK(NAME, PARAMS, NONPOINTER_PARAMS) \
+  template <typename T, typename = void> \
+  struct is_##NAME##_available : std::false_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME NONPOINTER_PARAMS) >> \
+    : std::true_type {};
+
+/* Everything fails with pointer to non-pointer mismatch.  */
+#define MAKE_ATOMIC_ASSERT(NAME, TYPE, SUCCESS) \
+  static_assert(is_##NAME##_available<TYPE>::value == false);
+
+#include "builtin-atomic-overloads.def"
diff --git a/gcc/testsuite/g++.dg/template/builtin-atomic-overloads3.C b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads3.C
new file mode 100644
index 00000000000..e872cc4b553
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads3.C
@@ -0,0 +1,19 @@
+/* Check that overloaded builtins can be used in templates with SFINAE.  */
+// { dg-do compile { target c++17 } }
+
+/* Checks performed here:
+   Too many arguments (all atomic builtins take less than 7 arguments).  */
+#define SFINAE_TYPE_CHECK(NAME, PARAMS, NONPOINTER_PARAMS) \
+  template <typename T, typename = void> \
+  struct is_##NAME##_available : std::false_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME \
+			(int(), int(), int(), int(), int(), int(), std::declval<T>())) >> \
+  : std::true_type {};
+
+/* Everything fails with too many arguments.  */
+#define MAKE_ATOMIC_ASSERT(NAME, TYPE, SUCCESS) \
+  static_assert(is_##NAME##_available<TYPE>::value == false);
+
+#include "builtin-atomic-overloads.def"
diff --git a/gcc/testsuite/g++.dg/template/builtin-atomic-overloads4.C b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads4.C
new file mode 100644
index 00000000000..7fd3dcb56aa
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads4.C
@@ -0,0 +1,19 @@
+/* Check that overloaded builtins can be used in templates with SFINAE.  */
+// { dg-do compile { target c++17 } }
+
+/* Checks performed here:
+   Too few arguments (all atomic functions require more than one argument).  */
+#define SFINAE_TYPE_CHECK(NAME, PARAMS, NONPOINTER_PARAMS) \
+  template <typename T, typename = void> \
+  struct is_##NAME##_available : std::false_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME (std::declval<T>())) >> \
+    : std::true_type {};
+
+
+/* Everything fails with too few arguments.  */
+#define MAKE_ATOMIC_ASSERT(NAME, TYPE, SUCCESS) \
+  static_assert(is_##NAME##_available<TYPE>::value == false);
+
+#include "builtin-atomic-overloads.def"
diff --git a/gcc/testsuite/g++.dg/template/builtin-atomic-overloads5.C b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads5.C
new file mode 100644
index 00000000000..44ada61a574
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads5.C
@@ -0,0 +1,329 @@
+/* Check that overloaded builtins still error when not in SFINAE context.  */
+// { dg-do compile { target c++17 } }
+#include <type_traits>
+
+/* Should error here due to the fully specified (and invalid) builtin calls.  */
+#define SFINAE_TYPE_CHECK(NAME, PARAMS, NONPOINTER_PARAMS) \
+  template <typename T, typename = void> \
+  struct is_##NAME##_available : std::false_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME (int())) >> \
+    : std::true_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME (int(), int())) >> \
+    : std::true_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME (int(), int(), int())) >> \
+    : std::true_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME (int(), int(), int(), int())) >> \
+    : std::true_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME (int(), int(), int(), int(), int())) >> \
+    : std::true_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME (int(), int(), int(), int(), int(), int())) >> \
+    : std::true_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME (X(), int())) >> \
+    : std::true_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME (Incomplete(), int())) >> \
+    : std::true_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME (int(), int(), int(), int(), \
+					  int(), int(), int())) >> \
+    : std::true_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME (std::declval<int*>(), int(), int(), int(), \
+					  int(), int(), int())) >> \
+    : std::true_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available<T, \
+    std::void_t<decltype(__atomic_##NAME ()) >> \
+    : std::true_type {};
+
+/* All the errors that are emitted.  We don't check that the errors directly
+   correspond to the relevant scenarios because validation that the correct
+   errors are generated for the relevant problems is done in other tests.
+
+   This test is checking that all the error types below are still emitted
+   when the problem occurs in templates for fully specified calls.
+
+   NOTE: We are missing some of the errors that could be emitted because the
+   above doesn't generate all invalid calls.
+   Things that could be added:
+      - pointer to incomplete type
+      - pointer to type of non-constant size
+      - pointer to type of zero size
+      - arguments after the first one:
+	- not pointers
+	- pointers to non-constant sized type
+	- pointers to function
+	- pointer to type of different size to the first one.
+	- pointer to const type
+	- pointer to volatile type
+      - memory model argument is not an integral type
+      - all errors around bitint
+      */
+
+/* { dg-error "argument 1 of '__atomic_compare_exchange' must be a non-void pointer type"                  "" { target *-*-* } 31 } */
+/* { dg-error "argument 1 of '__atomic_exchange' must be a non-void pointer type"                          "" { target *-*-* } 23 } */
+/* { dg-error "argument 1 of '__atomic_load' must be a non-void pointer type"                              "" { target *-*-* } 19 } */
+/* { dg-error "argument 1 of '__atomic_store' must be a non-void pointer type"                             "" { target *-*-* } 19 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_compare_exchange'"                      "" { target *-*-* } 11 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_compare_exchange'"                      "" { target *-*-* } 15 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_compare_exchange'"                      "" { target *-*-* } 19 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_compare_exchange'"                      "" { target *-*-* } 23 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_compare_exchange'"                      "" { target *-*-* } 27 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_compare_exchange'"                      "" { target *-*-* } 35 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_compare_exchange'"                      "" { target *-*-* } 39 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_compare_exchange'"                      "" { target *-*-* } 43 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_compare_exchange'"                      "" { target *-*-* } 48 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_compare_exchange'"                      "" { target *-*-* } 53 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_exchange'"                              "" { target *-*-* } 11 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_exchange'"                              "" { target *-*-* } 15 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_exchange'"                              "" { target *-*-* } 19 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_exchange'"                              "" { target *-*-* } 27 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_exchange'"                              "" { target *-*-* } 31 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_exchange'"                              "" { target *-*-* } 35 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_exchange'"                              "" { target *-*-* } 39 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_exchange'"                              "" { target *-*-* } 43 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_exchange'"                              "" { target *-*-* } 48 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_exchange'"                              "" { target *-*-* } 53 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_load'"                                  "" { target *-*-* } 11 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_load'"                                  "" { target *-*-* } 15 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_load'"                                  "" { target *-*-* } 23 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_load'"                                  "" { target *-*-* } 27 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_load'"                                  "" { target *-*-* } 31 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_load'"                                  "" { target *-*-* } 35 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_load'"                                  "" { target *-*-* } 39 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_load'"                                  "" { target *-*-* } 43 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_load'"                                  "" { target *-*-* } 48 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_load'"                                  "" { target *-*-* } 53 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_store'"                                 "" { target *-*-* } 11 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_store'"                                 "" { target *-*-* } 15 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_store'"                                 "" { target *-*-* } 23 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_store'"                                 "" { target *-*-* } 27 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_store'"                                 "" { target *-*-* } 31 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_store'"                                 "" { target *-*-* } 35 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_store'"                                 "" { target *-*-* } 39 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_store'"                                 "" { target *-*-* } 43 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_store'"                                 "" { target *-*-* } 48 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_store'"                                 "" { target *-*-* } 53 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_add_fetch'"          "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_and_fetch'"          "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_compare_exchange_n'" "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_exchange_n'"         "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_fetch_add'"          "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_fetch_and'"          "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_fetch_nand'"         "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_fetch_or'"           "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_fetch_sub'"          "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_fetch_xor'"          "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_load_n'"             "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_nand_fetch'"         "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_or_fetch'"           "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_store_n'"            "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_sub_fetch'"          "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'Incomplete' is incompatible with argument 1 of '__atomic_xor_fetch'"          "" { target *-*-* } 39 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_add_fetch'"                 "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_add_fetch'"                 "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_add_fetch'"                 "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_add_fetch'"                 "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_add_fetch'"                 "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_add_fetch'"                 "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_add_fetch'"                 "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_and_fetch'"                 "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_and_fetch'"                 "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_and_fetch'"                 "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_and_fetch'"                 "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_and_fetch'"                 "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_and_fetch'"                 "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_and_fetch'"                 "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_compare_exchange_n'"        "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_compare_exchange_n'"        "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_compare_exchange_n'"        "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_compare_exchange_n'"        "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_compare_exchange_n'"        "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_compare_exchange_n'"        "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_compare_exchange_n'"        "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_exchange_n'"                "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_exchange_n'"                "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_exchange_n'"                "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_exchange_n'"                "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_exchange_n'"                "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_exchange_n'"                "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_exchange_n'"                "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_add'"                 "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_add'"                 "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_add'"                 "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_add'"                 "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_add'"                 "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_add'"                 "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_add'"                 "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_and'"                 "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_and'"                 "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_and'"                 "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_and'"                 "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_and'"                 "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_and'"                 "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_and'"                 "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_nand'"                "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_nand'"                "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_nand'"                "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_nand'"                "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_nand'"                "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_nand'"                "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_nand'"                "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_or'"                  "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_or'"                  "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_or'"                  "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_or'"                  "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_or'"                  "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_or'"                  "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_or'"                  "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_sub'"                 "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_sub'"                 "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_sub'"                 "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_sub'"                 "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_sub'"                 "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_sub'"                 "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_sub'"                 "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_xor'"                 "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_xor'"                 "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_xor'"                 "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_xor'"                 "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_xor'"                 "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_xor'"                 "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_fetch_xor'"                 "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_load_n'"                    "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_load_n'"                    "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_load_n'"                    "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_load_n'"                    "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_load_n'"                    "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_load_n'"                    "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_load_n'"                    "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_nand_fetch'"                "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_nand_fetch'"                "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_nand_fetch'"                "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_nand_fetch'"                "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_nand_fetch'"                "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_nand_fetch'"                "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_nand_fetch'"                "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_or_fetch'"                  "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_or_fetch'"                  "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_or_fetch'"                  "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_or_fetch'"                  "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_or_fetch'"                  "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_or_fetch'"                  "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_or_fetch'"                  "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_store_n'"                   "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_store_n'"                   "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_store_n'"                   "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_store_n'"                   "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_store_n'"                   "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_store_n'"                   "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_store_n'"                   "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_sub_fetch'"                 "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_sub_fetch'"                 "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_sub_fetch'"                 "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_sub_fetch'"                 "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_sub_fetch'"                 "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_sub_fetch'"                 "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_sub_fetch'"                 "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_xor_fetch'"                 "" { target *-*-* } 11 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_xor_fetch'"                 "" { target *-*-* } 15 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_xor_fetch'"                 "" { target *-*-* } 19 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_xor_fetch'"                 "" { target *-*-* } 23 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_xor_fetch'"                 "" { target *-*-* } 27 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_xor_fetch'"                 "" { target *-*-* } 31 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_xor_fetch'"                 "" { target *-*-* } 43 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_add_fetch'"                   "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_and_fetch'"                   "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_compare_exchange_n'"          "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_exchange_n'"                  "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_fetch_add'"                   "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_fetch_and'"                   "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_fetch_nand'"                  "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_fetch_or'"                    "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_fetch_sub'"                   "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_fetch_xor'"                   "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_load_n'"                      "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_nand_fetch'"                  "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_or_fetch'"                    "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_store_n'"                     "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_sub_fetch'"                   "" { target *-*-* } 35 } */
+/* { dg-error "operand type 'X' is incompatible with argument 1 of '__atomic_xor_fetch'"                   "" { target *-*-* } 35 } */
+/* { dg-error "too few arguments to function '__atomic_add_fetch'"                                         "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_and_fetch'"                                         "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_compare_exchange_n'"                                "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_exchange_n'"                                        "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_fetch_add'"                                         "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_fetch_and'"                                         "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_fetch_nand'"                                        "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_fetch_or'"                                          "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_fetch_sub'"                                         "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_fetch_xor'"                                         "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_load_n'"                                            "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_nand_fetch'"                                        "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_or_fetch'"                                          "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_store_n'"                                           "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_sub_fetch'"                                         "" { target *-*-* } 53 } */
+/* { dg-error "too few arguments to function '__atomic_xor_fetch'"                                         "" { target *-*-* } 53 } */
+/* { dg-error "too many arguments to function '__atomic_add_fetch'"                                        "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_and_fetch'"                                        "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_compare_exchange_n'"                               "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_exchange_n'"                                       "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_fetch_add'"                                        "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_fetch_and'"                                        "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_fetch_nand'"                                       "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_fetch_or'"                                         "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_fetch_sub'"                                        "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_fetch_xor'"                                        "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_load_n'"                                           "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_nand_fetch'"                                       "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_or_fetch'"                                         "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_store_n'"                                          "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_sub_fetch'"                                        "" { target *-*-* } 48 } */
+/* { dg-error "too many arguments to function '__atomic_xor_fetch'"                                        "" { target *-*-* } 48 } */
+
+
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } 11 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } 15 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } 19 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } 23 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } 27 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } 31 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } 35 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } 39 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } 43 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } 48 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } 53 } */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } 11 } */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } 15 } */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } 19 } */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } 23 } */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } 27 } */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } 31 } */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } 35 } */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } 39 } */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } 44 } */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } 49 } */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } 53 } */
+
+/* Just avoid generating anything for the assertions (not what we're testing
+   here).  */
+#define MAKE_ATOMIC_ASSERT(NAME, TYPE, SUCCESS)
+
+#include "builtin-atomic-overloads.def"
diff --git a/gcc/testsuite/g++.dg/template/builtin-atomic-overloads6.C b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads6.C
new file mode 100644
index 00000000000..6ecf318b8c3
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads6.C
@@ -0,0 +1,171 @@
+/* Various atomic builtin errors are still emitted when in a fully specified
+   builtin in a template.  */
+// { dg-do compile { target c++17 } }
+// { dg-additional-options "-Wno-pedantic" }
+#include <type_traits>
+#ifdef __ARM_FEATURE_SVE
+#include <arm_sve.h>
+#endif
+
+/*
+   N.b. covering all if clauses, *not* all possible errors.
+   E.g. load, store, exchange, compare_exchange all go through
+   get_atomic_generic_size.  I ensure I test all if clauses in that function
+   but do not ensure each clause is hit when using each of the different
+   builtins.
+
+   N.b. this is the stuff that is not handled by
+   builtin-atomic-overloads{1,2,3,4,5}.C  */ 
+
+class X{};
+/* Want a zero-sized type in order to trigger one of the error messages.
+   Don't want the error message about creating a zero sized type.
+   However, *do* want to see any pedantic error messages coming from the rest
+   of the testcase.  */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+class Zero {
+    unsigned int trailing[0];
+};
+#pragma GCC diagnostic pop
+class Large { public: int arr[10]; };
+class Incomplete;
+/* N.b. If there are other non-constant size types that I can use in a template
+   would appreciate hearing about it (especially if they work on all targets).
+   AFAIK VLA's are the other canonical example and have not managed to trigger
+   the same error with those due to scoping limitations.  */
+#ifdef __ARM_FEATURE_SVE
+    typedef __SVUint32_t NonConstant;
+#else
+class NonConstant { };
+#endif
+typedef __UINT64_TYPE__ uint64_t;
+typedef __UINT32_TYPE__ uint32_t;
+// typedef _BitInt(12) Bitint;
+
+
+#define INCORRECT_NUMBER_ARGUMENTS(X) \
+  X(load, (int(), int(), int(), int()), 0)
+
+#define NONPOINTER_FIRST_ARG(X) \
+  X(load, (int(), int(), int()), 1)
+#define INCOMPLETE_FIRST_ARG(X) \
+  X(load, (Incomplete(), int(), int()), 2)
+/* This won't trigger relevant fail when not using nonconstant sized type.  */
+#define NONCONST_SIZE_FIRST_ARG(X) \
+  X(load, (std::declval<NonConstant*>(), std::declval<NonConstant*>(), int()), 3)
+#define ZEROSIZE_FIRST_ARG(X) \
+  X(load, (std::declval<Zero*>(), std::declval<Zero*>(), int()), 4)
+
+// Errors triggered by a bad type in the first position not yet triggered by
+// builtin-atomic-overloads5.C.
+// N.b. these are already checked to *not* give an error in the SFINAE context
+// by builtin-atomic-overloads1.C.
+#define FIRST_ARGS_BADTYPE(X) \
+  ZEROSIZE_FIRST_ARG(X) \
+  NONCONST_SIZE_FIRST_ARG(X) \
+  INCOMPLETE_FIRST_ARG(X) \
+  NONPOINTER_FIRST_ARG(X)
+
+#define NONPOINTER_OTHER_ARG(X) \
+  X(load, (std::declval<int*>(), int(), int()), 5)
+/* This won't trigger relevant fail when not using nonconstant sized type.  */
+#define NONCONST_SIZE_OTHER_ARG(X) \
+  X(load, (std::declval<int*>(), std::declval<NonConstant*>(), int()), 6)
+#define FUNCTIONPTR_OTHER_ARG(X) \
+  X(load, (std::declval<int*>(), std::declval<int(*)()>(), int()), 7)
+#define SIZE_MISMATCH(X) \
+  X(load, (std::declval<uint32_t*>(), std::declval<uint64_t*>(), int()), 8)
+#define OUTPUT_CONST(X) \
+  X(load, (std::declval<int*>(), std::declval<const int*>(), int()), 9)
+#define SECOND_VOLATILE(X) \
+  X(load, (std::declval<int*>(), std::declval<volatile int*>(), int()), 10)
+
+#define OTHER_ARG_BADTYPE(X) \
+  NONPOINTER_OTHER_ARG(X) \
+  SECOND_VOLATILE(X) \
+  OUTPUT_CONST(X) \
+  SIZE_MISMATCH(X) \
+  FUNCTIONPTR_OTHER_ARG(X) \
+  NONCONST_SIZE_OTHER_ARG(X)
+
+#define MEMMODEL_BADTYPE(X) \
+  X(load, (std::declval<int*>(), std::declval<int*>(), float()), 11)
+#define MEMMODEL_TOOLARGE(X) \
+  X(load, (std::declval<int*>(), std::declval<int*>(), 100), 12)
+
+#define MEMMODEL_BAD(X) \
+  MEMMODEL_BADTYPE(X) \
+  MEMMODEL_TOOLARGE(X)
+
+#define GET_ATOMIC_GENERIC_ERRS(X) \
+  INCORRECT_NUMBER_ARGUMENTS(X) \
+  FIRST_ARGS_BADTYPE(X) \
+  OTHER_ARG_BADTYPE(X) \
+  MEMMODEL_BAD(X)
+
+#define SYNC_SIZE_TOOFEW(X) \
+  X(load_n, (), 0)
+#define SYNC_SIZE_INCOMPATIBLE(X) \
+  X(load_n, (int(), int()), 1)
+#define SYNC_SIZE_ERRS(X) \
+  SYNC_SIZE_TOOFEW(X) \
+  SYNC_SIZE_INCOMPATIBLE(X)
+
+#define SYNC_PARM_TOOFEW(X) \
+  X(load_n, (std::declval<int*>()), 2)
+#define SYNC_PARM_TOOMANY(X) \
+  X(load_n, (std::declval<int*>(), int(), int()), 3)
+#define SYNC_PARM_ERRS(X) \
+  SYNC_PARM_TOOFEW(X) \
+  SYNC_PARM_TOOMANY(X)
+
+/*
+   No Bitint in C++.  Hence can't check for this error.
+#define BITINT_FETCHCAS_TOOFEW(X) \
+  X(add_fetch, (std::declval<Bitint*>(), std::declval<Bitint>()))
+#define BITINT_FETCHCAS_TOOMANY(X) \
+  X(add_fetch, (std::declval<Bitint*>(), std::declval<Bitint>(), int(), int()))
+#define BITINT_FETCHCAS_ERRS(X) \
+  BITINT_FETCHCAS_TOOFEW(X) \
+  BITINT_FETCHCAS_TOOMANY(X)
+*/
+#define BITINT_FETCHCAS_ERRS(X)
+
+#define ALL_ERRS(X) \
+  GET_ATOMIC_GENERIC_ERRS(X) \
+  SYNC_SIZE_ERRS(X) \
+  SYNC_PARM_ERRS(X) \
+  BITINT_FETCHCAS_ERRS(X)
+
+#define SFINAE_TYPE_CHECK(NAME, PARAMS, COUNTER) \
+  template <typename T, typename = void> \
+  struct is_##NAME##_available_##COUNTER : std::false_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available_##COUNTER<T, \
+    std::void_t<decltype(__atomic_##NAME PARAMS) >> \
+    : std::true_type {}; \
+
+ALL_ERRS(SFINAE_TYPE_CHECK)
+
+/* { dg-error "too few arguments to function '__atomic_load_n'"                          "" { target *-*-* } 108 } */
+/* { dg-error "operand type 'int' is incompatible with argument 1 of '__atomic_load_n'"  "" { target *-*-* } 110 } */
+/* { dg-error "too few arguments to function '__atomic_load_n'"                          "" { target *-*-* } 116 } */
+/* { dg-error "too many arguments to function '__atomic_load_n'"                         "" { target *-*-* } 118 } */
+/* { dg-error "template argument 1 is invalid"                                           "" { target *-*-* } 146 } */
+/* { dg-error "template argument 2 is invalid"                                           "" { target *-*-* } 146 } */
+/* { dg-error "incorrect number of arguments to function '__atomic_load'"                "" { target *-*-* } 48 } */
+/* { dg-error "argument 1 of '__atomic_load' must be a non-void pointer type"            "" { target *-*-* } 51 } */
+/* { dg-error "argument 1 of '__atomic_load' must be a non-void pointer type"            "" { target *-*-* } 53 } */
+/* { dg-error "argument 1 of '__atomic_load' must be a pointer to a constant size type"  "" { target aarch64_sve } 56 } */
+/* { dg-error "argument 1 of '__atomic_load' must be a pointer to a nonzero size object" "" { target *-*-* } 58 } */
+/* { dg-error "argument 2 of '__atomic_load' must be a pointer type"                     "" { target *-*-* } 71 } */
+/* { dg-error "argument 2 of '__atomic_load' must be a pointer to a constant size type"  "" { target aarch64_sve } 74 } */
+/* { dg-error "size mismatch in argument 2 of '__atomic_load'"                           "" { target { ! aarch64_sve } } 74 } */
+/* { dg-error "argument 2 of '__atomic_load' must not be a pointer to a function"        "" { target *-*-* } 76 } */
+/* { dg-error "size mismatch in argument 2 of '__atomic_load'"                           "" { target *-*-* } 78 } */
+/* { dg-error "argument 2 of '__atomic_load' must not be a pointer to a 'const' type"    "" { target *-*-* } 80 } */
+/* { dg-error "argument 2 of '__atomic_load' must not be a pointer to a 'volatile' type" "" { target *-*-* } 82 } */
+/* { dg-error "non-integer memory model argument 3 of '__atomic_load'"                   "" { target *-*-* } 93 } */
+
+/* { dg-warning {invalid memory model argument 3 of '__atomic_load' \[-Winvalid-memory-model\]} "" { target *-*-* } 95 } */
diff --git a/gcc/testsuite/g++.dg/template/builtin-atomic-overloads7.C b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads7.C
new file mode 100644
index 00000000000..ef1d4627758
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-atomic-overloads7.C
@@ -0,0 +1,170 @@
+/* Various atomic builtin errors not emitted when in SFINAE context.  */
+// { dg-do compile { target c++17 } }
+// { dg-additional-options "-Wno-pedantic" }
+#include <type_traits>
+#ifdef __ARM_FEATURE_SVE
+#include <arm_sve.h>
+#endif
+
+/*
+   N.b. covering all if clauses, *not* all possible errors.
+   E.g. load, store, exchange, compare_exchange all go through
+   get_atomic_generic_size.  I ensure I test all if clauses in that function
+   but do not ensure each clause is hit when using each of the different
+   builtins.
+
+   N.b. this is the stuff that is not handled by
+   builtin-atomic-overloads{1,2,3,4,5}.C  */ 
+
+class X{};
+/* Want a zero-sized type in order to trigger one of the error messages.
+   Don't want the error message about creating a zero sized type.
+   However, *do* want to see any pedantic error messages coming from the rest
+   of the testcase (shouldn't be any, but would like to be alerted if there
+   are).  */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+class Zero {
+    unsigned int trailing[0];
+};
+#pragma GCC diagnostic pop
+class Large { public: int arr[10]; };
+class Incomplete;
+/* N.b. If there are other non-constant size types that I can use in a template
+   would appreciate hearing about it (especially if they work on all targets).
+   AFAIK VLA's are the other canonical example and have not managed to trigger
+   the same error with those due to scoping limitations.  */
+#ifdef __ARM_FEATURE_SVE
+    typedef __SVUint32_t NonConstant;
+#else
+class NonConstant { };
+#endif
+typedef __UINT64_TYPE__ uint64_t;
+typedef __UINT32_TYPE__ uint32_t;
+// typedef _BitInt(12) Bitint;
+
+
+#define INCORRECT_NUMBER_ARGUMENTS(X) \
+  X(load, (std::declval<T>(), int(), int(), int()), 0)
+
+#define NONPOINTER_FIRST_ARG(X) \
+  X(load, (std::declval<std::remove_pointer_t<T>>(), int(), int()), 1)
+#define INCOMPLETE_FIRST_ARG(X) \
+  X(load, (std::declval<Incomplete*>(), std::declval<T>(), int()), 2)
+/* This won't trigger relevant fail when not using nonconstant sized type.  */
+#define NONCONST_SIZE_FIRST_ARG(X) \
+  X(load, (std::declval<NonConstant*>(), std::declval<T>(), int()), 3)
+#define ZEROSIZE_FIRST_ARG(X) \
+  X(load, (std::declval<Zero*>(), std::declval<T>(), int()), 4)
+
+// Errors triggered by a bad type in the first position not yet triggered by
+// builtin-atomic-overloads5.C.
+// N.b. these are already checked to *not* give an error in the SFINAE context
+// by builtin-atomic-overloads1.C.
+#define FIRST_ARGS_BADTYPE(X) \
+  ZEROSIZE_FIRST_ARG(X) \
+  NONCONST_SIZE_FIRST_ARG(X) \
+  INCOMPLETE_FIRST_ARG(X) \
+  NONPOINTER_FIRST_ARG(X)
+
+#define NONPOINTER_OTHER_ARG(X) \
+  X(load, (std::declval<T>(), int(), int()), 5)
+/* This won't trigger relevant fail when not using nonconstant sized type.  */
+#define NONCONST_SIZE_OTHER_ARG(X) \
+  X(load, (std::declval<T>(), std::declval<NonConstant*>(), int()), 6)
+#define FUNCTIONPTR_OTHER_ARG(X) \
+  X(load, (std::declval<T>(), std::declval<int(*)()>(), int()), 7)
+#define SIZE_MISMATCH(X) \
+  X(load, (std::declval<T>(), std::declval<uint64_t*>(), int()), 8)
+#define OUTPUT_CONST(X) \
+  X(load, (std::declval<T>(), std::declval<const int*>(), int()), 9)
+#define SECOND_VOLATILE(X) \
+  X(load, (std::declval<T>(), std::declval<volatile int*>(), int()), 10)
+
+#define OTHER_ARG_BADTYPE(X) \
+  NONPOINTER_OTHER_ARG(X) \
+  SECOND_VOLATILE(X) \
+  OUTPUT_CONST(X) \
+  SIZE_MISMATCH(X) \
+  FUNCTIONPTR_OTHER_ARG(X) \
+  NONCONST_SIZE_OTHER_ARG(X)
+
+#define MEMMODEL_BADTYPE(X) \
+  X(load, (std::declval<T>(), std::declval<int*>(), float()), 11)
+/* Don't include this in ALL_ERRS since this is a warning should still resolve
+   to `true` so we need a different ASSERT macro for it. */
+/* { dg-warning {invalid memory model argument 3 of '__atomic_load' \[-Winvalid-memory-model\]} "" { target *-*-* } .+2 } */
+#define MEMMODEL_TOOLARGE(X) \
+  X(load, (std::declval<T>(), std::declval<int*>(), 100), 12)
+
+#define MEMMODEL_BAD(X) \
+  MEMMODEL_BADTYPE(X) \
+
+#define GET_ATOMIC_GENERIC_ERRS(X) \
+  INCORRECT_NUMBER_ARGUMENTS(X) \
+  FIRST_ARGS_BADTYPE(X) \
+  OTHER_ARG_BADTYPE(X) \
+  MEMMODEL_BAD(X)
+
+/*  Can't trigger this error in SFINAE context since in order to trigger error
+    need zero arguments, but that means type is fully specified.
+    
+#define SYNC_SIZE_TOOFEW(X) \
+  X(load_n, (), 0)
+  */
+#define SYNC_SIZE_TOOFEW(X)
+#define SYNC_SIZE_INCOMPATIBLE(X) \
+  X(load_n, (int(), std::declval<T>()), 1)
+#define SYNC_SIZE_ERRS(X) \
+  SYNC_SIZE_TOOFEW(X) \
+  SYNC_SIZE_INCOMPATIBLE(X)
+
+#define SYNC_PARM_TOOFEW(X) \
+  X(load_n, (std::declval<T>()), 2)
+#define SYNC_PARM_TOOMANY(X) \
+  X(load_n, (std::declval<T>(), int(), int()), 3)
+#define SYNC_PARM_ERRS(X) \
+  SYNC_PARM_TOOFEW(X) \
+  SYNC_PARM_TOOMANY(X)
+
+/*
+   No Bitint in C++.  Hence can't check for this error.
+#define BITINT_FETCHCAS_TOOFEW(X) \
+  X(add_fetch, (std::declval<Bitint*>(), std::declval<Bitint>()))
+#define BITINT_FETCHCAS_TOOMANY(X) \
+  X(add_fetch, (std::declval<Bitint*>(), std::declval<Bitint>(), int(), int()))
+#define BITINT_FETCHCAS_ERRS(X) \
+  BITINT_FETCHCAS_TOOFEW(X) \
+  BITINT_FETCHCAS_TOOMANY(X)
+*/
+#define BITINT_FETCHCAS_ERRS(X)
+
+#define ALL_ERRS(X) \
+  GET_ATOMIC_GENERIC_ERRS(X) \
+  SYNC_SIZE_ERRS(X) \
+  SYNC_PARM_ERRS(X) \
+  BITINT_FETCHCAS_ERRS(X)
+
+#define SFINAE_TYPE_CHECK(NAME, PARAMS, COUNTER) \
+  template <typename T, typename = void> \
+  struct is_##NAME##_available_##COUNTER : std::false_type {}; \
+  template <typename T> \
+  struct is_##NAME##_available_##COUNTER<T, \
+    std::void_t<decltype(__atomic_##NAME PARAMS) >> \
+    : std::true_type {}; \
+
+ALL_ERRS(SFINAE_TYPE_CHECK)
+MEMMODEL_TOOLARGE(SFINAE_TYPE_CHECK)
+
+#define ASSERT(NAME, PARAMS, COUNTER) \
+  static_assert(is_##NAME##_available_##COUNTER<int*>::value == false);
+
+#define ASSERT_TRUE(NAME, PARAMS, COUNTER) \
+  static_assert(is_##NAME##_available_##COUNTER<int*>::value == true);
+
+int foo() {
+    ALL_ERRS(ASSERT)
+    MEMMODEL_TOOLARGE(ASSERT_TRUE)
+    return 1;
+}
+
diff --git a/gcc/testsuite/g++.dg/template/builtin-sfinae-check-function-arguments.C b/gcc/testsuite/g++.dg/template/builtin-sfinae-check-function-arguments.C
new file mode 100644
index 00000000000..1dbf4d7df0c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-sfinae-check-function-arguments.C
@@ -0,0 +1,145 @@
+/* Testing various builtins don't complain about incorrect number of arguments.  */
+// { dg-do compile { target c++17 } }
+#include <type_traits>
+
+/* Here checking the check_builtin_function_arguments function doesn't error
+   in an SFINAE context.  Test each of the errors that are directly emitted
+   from check_builtin_function_arguments.  */
+
+class BasicClass { };
+class Incomplete;
+enum En { En_A };
+
+/* N.b. Do not include tests against the *_overflow error message of storing to
+   atomic types since I don't know how to make a type that is both TYPE_ATOMIC
+   and INTEGRAL_TYPE_P in C++ (where _Atomic is not a keyword).
+   Similar for clear_padding error message on _Atomic integral types.  */
+#define NARGS_CHECKS(X)                                                        \
+  X (clrsbg, (std::declval<T> ()), unsigned, 4)                                \
+  X (ffsg, (std::declval<T> ()), unsigned, 4)                                  \
+  X (clzg, (std::declval<T> ()), int, 4)                                       \
+  X (ctzg, (std::declval<T> ()), int, 4)                                       \
+  X (parityg, (std::declval<T> ()), int, 4)                                    \
+  X (popcountg, (std::declval<T> ()), int, 4)                                  \
+  X (clzg, (std::declval<T> ()), bool, 3)                                      \
+  X (ctzg, (std::declval<T> ()), bool, 3)                                      \
+  X (clrsbg, (std::declval<T> ()), bool, 3)                                    \
+  X (ffsg, (std::declval<T> ()), bool, 3)                                      \
+  X (parityg, (std::declval<T> ()), bool, 3)                                   \
+  X (popcountg, (std::declval<T> ()), bool, 3)                                 \
+  X (clzg, (std::declval<T> ()), En, 2)                                        \
+  X (ctzg, (std::declval<T> ()), En, 2)                                        \
+  X (clrsbg, (std::declval<T> ()), En, 2)                                      \
+  X (ffsg, (std::declval<T> ()), En, 2)                                        \
+  X (parityg, (std::declval<T> ()), En, 2)                                     \
+  X (popcountg, (std::declval<T> ()), En, 2)                                   \
+  X (clzg, (std::declval<T> ()), float, 1)                                     \
+  X (ctzg, (std::declval<T> ()), float, 1)                                     \
+  X (clrsbg, (std::declval<T> ()), float, 1)                                   \
+  X (ffsg, (std::declval<T> ()), float, 1)                                     \
+  X (parityg, (std::declval<T> ()), float, 1)                                  \
+  X (popcountg, (std::declval<T> ()), float, 1)                                \
+  X (clzg, (std::declval<T> (), std::declval<long> ()), int, 101)              \
+  X (ctzg, (std::declval<T> (), std::declval<long> ()), int, 101)              \
+  X (clzg, (std::declval<T> (), std::declval<T> ()), float, 100)               \
+  X (ctzg, (std::declval<T> (), std::declval<T> ()), float, 100)               \
+  X (clear_padding, (std::declval<T *> ()), const int, 3)                      \
+  X (clear_padding, (std::declval<T *> ()), Incomplete, 2)                     \
+  X (clear_padding, (std::declval<T> ()), int, 1)                              \
+  X (add_overflow_p,                                                           \
+     (std::declval<T> (), std::declval<T> (), std::declval<bool> ()), int, 3)  \
+  X (sub_overflow_p,                                                           \
+     (std::declval<T> (), std::declval<T> (), std::declval<bool> ()), int, 3)  \
+  X (mul_overflow_p,                                                           \
+     (std::declval<T> (), std::declval<T> (), std::declval<bool> ()), int, 3)  \
+  X (add_overflow_p,                                                           \
+     (std::declval<T> (), std::declval<T> (), std::declval<En> ()), int, 2)    \
+  X (sub_overflow_p,                                                           \
+     (std::declval<T> (), std::declval<T> (), std::declval<En> ()), int, 2)    \
+  X (mul_overflow_p,                                                           \
+     (std::declval<T> (), std::declval<T> (), std::declval<En> ()), int, 2)    \
+  X (add_overflow_p,                                                           \
+     (std::declval<T> (), std::declval<T> (), std::declval<T> ()), float, 1)   \
+  X (sub_overflow_p,                                                           \
+     (std::declval<T> (), std::declval<T> (), std::declval<T> ()), float, 1)   \
+  X (mul_overflow_p,                                                           \
+     (std::declval<T> (), std::declval<T> (), std::declval<T> ()), float, 1)   \
+  X (mul_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<const int *> ()),   \
+     int, 5)                                                                   \
+  X (sub_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<const int *> ()),   \
+     int, 5)                                                                   \
+  X (add_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<const int *> ()),   \
+     int, 5)                                                                   \
+  X (mul_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<bool *> ()), int,   \
+     4)                                                                        \
+  X (sub_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<bool *> ()), int,   \
+     4)                                                                        \
+  X (add_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<bool *> ()), int,   \
+     4)                                                                        \
+  X (mul_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<En *> ()), int, 3)  \
+  X (sub_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<En *> ()), int, 3)  \
+  X (add_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<En *> ()), int, 3)  \
+  X (mul_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<T> ()), int, 2)     \
+  X (sub_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<T> ()), int, 2)     \
+  X (add_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<T> ()), int, 2)     \
+  X (mul_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<T *> ()), float, 1) \
+  X (sub_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<T *> ()), float, 1) \
+  X (add_overflow,                                                             \
+     (std::declval<T> (), std::declval<T> (), std::declval<T *> ()), float, 1) \
+  X (assume_aligned, (std::declval<int *> (), int (), std::declval<T> ()),     \
+     float, 1)                                                                 \
+  X (fpclassify,                                                               \
+     (std::declval<T> (), int (), int (), int (), int (), std::declval<T> ()), \
+     int, 2)                                                                   \
+  X (fpclassify,                                                               \
+     (std::declval<T> (), int (), int (), int (), int (), float ()), float, 1) \
+  X (isgreater, (std::declval<T> (), std::declval<T> ()), int, 1)              \
+  X (isgreaterequal, (std::declval<T> (), std::declval<T> ()), int, 1)         \
+  X (isless, (std::declval<T> (), std::declval<T> ()), int, 1)                 \
+  X (islessequal, (std::declval<T> (), std::declval<T> ()), int, 1)            \
+  X (islessgreater, (std::declval<T> (), std::declval<T> ()), int, 1)          \
+  X (isunordered, (std::declval<T> (), std::declval<T> ()), int, 1)            \
+  X (iseqsig, (std::declval<T> (), std::declval<T> ()), int, 1)                \
+  X (isinf_sign, (std::declval<T> ()), int, 1)                                 \
+  X (isnan, (std::declval<T> ()), int, 1)                                      \
+  X (isnormal, (std::declval<T> ()), int, 1)                                   \
+  X (issignaling, (std::declval<T> ()), int, 1)                                \
+  X (signbit, (std::declval<T> ()), int, 1)                                    \
+  X (isinf, (std::declval<T> ()), int, 1)                                      \
+  X (isfinite, (std::declval<T> ()), int, 1)                                   \
+  X (alloca_with_align, (int (), int (), std::declval<T> ()), BasicClass, 1)   \
+  X (alloca_with_align_and_max, (std::declval<T> (), 1), int, 1)
+
+#define TEMPLATE_DEFS(NAME, PARAMS, TYPE, NUM)                                 \
+  template <typename T, typename = void>                                       \
+  struct is_##NAME##_available_##NUM : std::false_type                         \
+  {                                                                            \
+  };                                                                           \
+  template <typename T>                                                        \
+  struct is_##NAME##_available_##NUM<                                          \
+    T, std::void_t<decltype (__builtin_##NAME PARAMS)>> : std::true_type       \
+  {                                                                            \
+  };
+
+NARGS_CHECKS(TEMPLATE_DEFS)
+
+#define MAKE_ASSERT(NAME, PARAMS, TYPE, NUM) \
+  static_assert(is_##NAME##_available_##NUM<TYPE>::value == false);
+
+void foo() {
+    NARGS_CHECKS(MAKE_ASSERT)
+}
diff --git a/gcc/testsuite/g++.dg/template/builtin-speculation-overloads.def b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads.def
new file mode 100644
index 00000000000..39d9b748d52
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads.def
@@ -0,0 +1,30 @@
+#include <type_traits>
+
+/* Use std::remove_pointer_t<T> here in order to make `int *` fail when using
+   the INVALID_PARAMETERS block.  Pointers of two different types are allowed
+   in __builtin_speculation_safe_value, it's one argument of a pointer and
+   another argument that is not a pointer that give errors.  */
+#define SPECULATION_SFINAES                                                    \
+  SFINAE_TYPE_CHECK ((std::declval<T> (), std::declval<T> ()),                 \
+		     (std::declval<T> ()),                                     \
+		     (std::declval<std::remove_pointer_t<T>> (), std::declval<T *> ()))
+
+SPECULATION_SFINAES
+
+class X{};
+class Large { public: int arr[10]; };
+class Incomplete;
+
+#define SPECULATION_ASSERTS                                                    \
+  MAKE_SPECULATION_ASSERT (int, true)                                          \
+  MAKE_SPECULATION_ASSERT (float, false)                                       \
+  MAKE_SPECULATION_ASSERT (X, false)                                           \
+  MAKE_SPECULATION_ASSERT (Large, false)                                       \
+  MAKE_SPECULATION_ASSERT (Incomplete, false)                                  \
+  MAKE_SPECULATION_ASSERT (int *, true)                                        \
+  MAKE_SPECULATION_ASSERT (long, true)
+
+int main() {
+    SPECULATION_ASSERTS
+    return 0;
+}
diff --git a/gcc/testsuite/g++.dg/template/builtin-speculation-overloads1.C b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads1.C
new file mode 100644
index 00000000000..bc8f1083a99
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads1.C
@@ -0,0 +1,18 @@
+/* Check that overloaded builtins can be used in templates with SFINAE.  */
+// { dg-do compile { target c++17 } }
+
+/* Checks performed here:
+   Various types (some that work, some that don't).  */
+#define SFINAE_TYPE_CHECK(PARAMS, SHORTENED_PARAMS, INVALID_PARAMS) \
+  template <typename T, typename = void> \
+  struct is_available : std::false_type {}; \
+  template <typename T> \
+  struct is_available<T, \
+    std::void_t<decltype(__builtin_speculation_safe_value PARAMS) >> \
+    : std::true_type {};
+
+/* Success according to type of argument.  */
+#define MAKE_SPECULATION_ASSERT(TYPE, SUCCESS) \
+  static_assert(is_available<TYPE>::value == SUCCESS);
+
+#include "builtin-speculation-overloads.def"
diff --git a/gcc/testsuite/g++.dg/template/builtin-speculation-overloads2.C b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads2.C
new file mode 100644
index 00000000000..842e349037c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads2.C
@@ -0,0 +1,19 @@
+/* Check that overloaded builtins can be used in templates with SFINAE.  */
+// { dg-do compile { target c++17 } }
+
+/* Checks performed here:
+   Invalid parameters with various types (mismatching pointer and non-pointer
+   types).  */
+#define SFINAE_TYPE_CHECK(PARAMS, SHORTENED_PARAMS, INVALID_PARAMS) \
+  template <typename T, typename = void> \
+  struct is_available : std::false_type {}; \
+  template <typename T> \
+  struct is_available<T, \
+    std::void_t<decltype(__builtin_speculation_safe_value INVALID_PARAMS) >> \
+    : std::true_type {};
+
+/* Mismatching pointer/non-pointer typed parameters always fail.  */
+#define MAKE_SPECULATION_ASSERT(TYPE, SUCCESS) \
+  static_assert(is_available<TYPE>::value == false);
+
+#include "builtin-speculation-overloads.def"
diff --git a/gcc/testsuite/g++.dg/template/builtin-speculation-overloads3.C b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads3.C
new file mode 100644
index 00000000000..79956dd972f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads3.C
@@ -0,0 +1,20 @@
+/* Check that overloaded builtins can be used in templates with SFINAE.  */
+// { dg-do compile { target c++17 } }
+
+/* Checks performed here:
+   Too many arguments (for any type three arguments should be invalid).  */
+#define SFINAE_TYPE_CHECK(PARAMS, SHORTENED_PARAMS, INVALID_PARAMS) \
+  template <typename T, typename = void> \
+  struct is_available : std::false_type {}; \
+  template <typename T> \
+  struct is_available<T, \
+    std::void_t<decltype(__builtin_speculation_safe_value \
+			 (int(), int(), std::declval<T>())) >> \
+    : std::true_type {};
+
+/* All types should fail with three arguments.  */
+#define MAKE_SPECULATION_ASSERT(TYPE, SUCCESS) \
+  static_assert(is_available<TYPE>::value == false);
+
+#include "builtin-speculation-overloads.def"
+
diff --git a/gcc/testsuite/g++.dg/template/builtin-speculation-overloads4.C b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads4.C
new file mode 100644
index 00000000000..c024a21fa18
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads4.C
@@ -0,0 +1,19 @@
+/* Check that overloaded builtins can be used in templates with SFINAE.  */
+// { dg-do compile { target c++17 } }
+
+/* Checks performed here:
+   Optional parameter missing works same as with optional parameter specified.  */
+#define SFINAE_TYPE_CHECK(PARAMS, SHORTENED_PARAMS, INVALID_PARAMS) \
+  template <typename T, typename = void> \
+  struct is_available : std::false_type {}; \
+  template <typename T> \
+  struct is_available<T, \
+    std::void_t<decltype(__builtin_speculation_safe_value SHORTENED_PARAMS) >> \
+    : std::true_type {};
+
+/* All types should fail with three arguments.  */
+#define MAKE_SPECULATION_ASSERT(TYPE, SUCCESS) \
+  static_assert(is_available<TYPE>::value == SUCCESS);
+
+#include "builtin-speculation-overloads.def"
+
diff --git a/gcc/testsuite/g++.dg/template/builtin-speculation-overloads5.C b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads5.C
new file mode 100644
index 00000000000..8bccafb0e20
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-speculation-overloads5.C
@@ -0,0 +1,33 @@
+/* Check that overloaded builtins still error when not in SFINAE context.  */
+// { dg-do compile { target c++17 } }
+#include <type_traits>
+
+/* Checks performed here:
+   Fully specified and invalid function errors before SFINAE happens.  */
+template <typename T, typename = void> struct is_available : std::false_type
+{
+};
+
+/* Should be error here because of the fully specified (and invalid) builtin
+   call. */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } .+5 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } .+4 } */
+/* { dg-error "too few arguments to function" "" { target *-*-* } .+3 } */
+template <typename T>
+struct is_available<
+  T, std::void_t<decltype (__builtin_speculation_safe_value ())>>
+  : std::true_type
+{
+};
+
+/* Should be error here because of the fully specified (and invalid) builtin
+   call. */
+/* { dg-error "template argument 2 is invalid" "" { target *-*-* } .+5 } */
+/* { dg-error "template argument 1 is invalid" "" { target *-*-* } .+4 } */
+/* { dg-error "operand type 'float' is incompatible" "" { target *-*-* } .+3 } */
+template <typename T>
+struct is_available<
+  T, std::void_t<decltype (__builtin_speculation_safe_value (float()))>>
+  : std::true_type
+{
+};
diff --git a/gcc/testsuite/g++.dg/template/builtin-validate-nargs.C b/gcc/testsuite/g++.dg/template/builtin-validate-nargs.C
new file mode 100644
index 00000000000..c6a7aec48d4
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/builtin-validate-nargs.C
@@ -0,0 +1,67 @@
+/* Testing that we avoid error in SFINAE context when number of arguments are
+   invalid in a builtin template argument.  */
+// { dg-do compile { target c++17 } }
+/* { dg-additional-options "-Wno-macro-redefined" { target { *-*-* } } } */
+#include <type_traits>
+
+/* Here checking the builtin_function_validate_nargs function doesn't error
+   in an SFINAE context.  */
+
+template <typename T, typename = void> struct is_available : std::false_type
+{
+};
+
+/* Make one testcase for each of the functions in
+   check_builtin_function_arguments that uses builtin_function_validate_nargs.
+ */
+#define NARGS_CHECKS(X)                                                        \
+  X (constant_p, (std::declval<T> (), std::declval<T> ()))                     \
+  X (isfinite, (std::declval<T> (), std::declval<T> ()))                       \
+  X (isinf, (std::declval<T> (), std::declval<T> ()))                          \
+  X (isinf_sign, (std::declval<T> (), std::declval<T> ()))                     \
+  X (isnan, (std::declval<T> (), std::declval<T> ()))                          \
+  X (isnormal, (std::declval<T> (), std::declval<T> ()))                       \
+  X (issignaling, (std::declval<T> (), std::declval<T> ()))                    \
+  X (signbit, (std::declval<T> (), std::declval<T> ()))                        \
+  X (isgreater, (std::declval<T> ()))                                          \
+  X (isgreaterequal, (std::declval<T> ()))                                     \
+  X (isless, (std::declval<T> ()))                                             \
+  X (islessequal, (std::declval<T> ()))                                        \
+  X (islessgreater, (std::declval<T> ()))                                      \
+  X (isunordered, (std::declval<T> ()))                                        \
+  X (iseqsig, (std::declval<T> ()))                                            \
+  X (fpclassify, (std::declval<T> ()))                                         \
+  X (assume_aligned, (std::declval<T> ()))                                     \
+  X (add_overflow, (std::declval<T> ()))                                       \
+  X (sub_overflow, (std::declval<T> ()))                                       \
+  X (mul_overflow, (std::declval<T> ()))                                       \
+  X (add_overflow_p, (std::declval<T> ()))                                     \
+  X (sub_overflow_p, (std::declval<T> ()))                                     \
+  X (mul_overflow_p, (std::declval<T> ()))                                     \
+  X (clear_padding, (std::declval<T> (), std::declval<T> ()))                  \
+  X (clzg, (std::declval<T> (), std::declval<T> (), std::declval<T> ()))       \
+  X (ctzg, (std::declval<T> (), std::declval<T> (), std::declval<T> ()))       \
+  X (clrsbg, (std::declval<T> (), std::declval<T> (), std::declval<T> ()))     \
+  X (ffsg, (std::declval<T> (), std::declval<T> (), std::declval<T> ()))       \
+  X (parityg, (std::declval<T> (), std::declval<T> (), std::declval<T> ()))    \
+  X (popcountg, (std::declval<T> (), std::declval<T> (), std::declval<T> ()))
+
+#define TEMPLATE_DEFS(NAME, PARAMS)                                            \
+  template <typename T, typename = void>                                       \
+  struct is_##NAME##_available : std::false_type                               \
+  {                                                                            \
+  };                                                                           \
+  template <typename T>                                                        \
+  struct is_##NAME##_available<                                                \
+    T, std::void_t<decltype (__builtin_##NAME PARAMS)>> : std::true_type       \
+  {                                                                            \
+  };
+
+NARGS_CHECKS(TEMPLATE_DEFS)
+
+#define MAKE_ASSERT(NAME, PARAMS) \
+  static_assert(is_##NAME##_available<int>::value == false);
+
+void foo() {
+    NARGS_CHECKS(MAKE_ASSERT)
+}
-- 
2.43.0