Re: [PATCH 01/18] rs6000: Handle overloads during program parsing

[will schmidt <will_schmidt@vnet.ibm.com>]

On Wed, 2021-09-01 at 11:13 -0500, Bill Schmidt via Gcc-patches wrote:

Hi, 
  Just a couple cosmetic nits noted below, the majority if which is also in
the original code this is based on.  
THanks
-Will


> Although this patch looks quite large, the changes are fairly minimal.
> Most of it is duplicating the large function that does the overload
> resolution using the automatically generated data structures instead of
> the old hand-generated ones.  This doesn't make the patch terribly easy to
> review, unfortunately.  Just be aware that generally we aren't changing
> the logic and functionality of overload handling.

ok


> 
> 2021-08-31  Bill Schmidt  <wschmidt@linux.ibm.com>
> 
> gcc/
> 	* config/rs6000/rs6000-c.c (rs6000-builtins.h): New include.
> 	(altivec_resolve_new_overloaded_builtin): New forward decl.
> 	(rs6000_new_builtin_type_compatible): New function.
> 	(altivec_resolve_overloaded_builtin): Call
> 	altivec_resolve_new_overloaded_builtin.
> 	(altivec_build_new_resolved_builtin): New function.
> 	(altivec_resolve_new_overloaded_builtin): Likewise.
> 	* config/rs6000/rs6000-call.c (rs6000_new_builtin_is_supported):
> 	Likewise.
> 	* config/rs6000/rs6000-gen-builtins.c (write_decls): Remove _p from
> 	name of rs6000_new_builtin_is_supported.


ok

> ---
>  gcc/config/rs6000/rs6000-c.c            | 1088 +++++++++++++++++++++++
>  gcc/config/rs6000/rs6000-call.c         |   53 ++
>  gcc/config/rs6000/rs6000-gen-builtins.c |    2 +-
>  3 files changed, 1142 insertions(+), 1 deletion(-)
> 
> diff --git a/gcc/config/rs6000/rs6000-c.c b/gcc/config/rs6000/rs6000-c.c
> index afcb5bb6e39..aafb4e6a98f 100644
> --- a/gcc/config/rs6000/rs6000-c.c
> +++ b/gcc/config/rs6000/rs6000-c.c
> @@ -35,6 +35,9 @@
>  #include "langhooks.h"
>  #include "c/c-tree.h"
> 
> +#include "rs6000-builtins.h"
> +
> +static tree altivec_resolve_new_overloaded_builtin (location_t, tree, void *);
> 
> 
>  /* Handle the machine specific pragma longcall.  Its syntax is
> @@ -811,6 +814,30 @@ is_float128_p (tree t)
>  	      && t == long_double_type_node));
>  }
> 
> +static bool
> +rs6000_new_builtin_type_compatible (tree t, tree u)
> +{
> +  if (t == error_mark_node)
> +    return false;
> +
> +  if (INTEGRAL_TYPE_P (t) && INTEGRAL_TYPE_P (u))
> +    return true;
> +
> +  if (TARGET_IEEEQUAD && TARGET_LONG_DOUBLE_128
> +      && is_float128_p (t) && is_float128_p (u))
> +    return true;
> +
> +  if (POINTER_TYPE_P (t) && POINTER_TYPE_P (u))
> +    {
> +      t = TREE_TYPE (t);
> +      u = TREE_TYPE (u);
> +      if (TYPE_READONLY (u))
> +	t = build_qualified_type (t, TYPE_QUAL_CONST);
> +    }
> +
> +  return lang_hooks.types_compatible_p (t, u);
> +}
> +

ok

>  static inline bool
>  rs6000_builtin_type_compatible (tree t, int id)
>  {
> @@ -927,6 +954,10 @@ tree
>  altivec_resolve_overloaded_builtin (location_t loc, tree fndecl,
>  				    void *passed_arglist)
>  {
> +  if (new_builtins_are_live)
> +    return altivec_resolve_new_overloaded_builtin (loc, fndecl,
> +						   passed_arglist);
> +
>    vec<tree, va_gc> *arglist = static_cast<vec<tree, va_gc> *> (passed_arglist);
>    unsigned int nargs = vec_safe_length (arglist);
>    enum rs6000_builtins fcode

ok

> @@ -1930,3 +1961,1060 @@ altivec_resolve_overloaded_builtin (location_t loc, tree fndecl,
>      return error_mark_node;
>    }
>  }
> +
> +/* Build a tree for a function call to an Altivec non-overloaded builtin.
> +   The overloaded builtin that matched the types and args is described
> +   by DESC.  The N arguments are given in ARGS, respectively.
> +
> +   Actually the only thing it does is calling fold_convert on ARGS, with
> +   a small exception for vec_{all,any}_{ge,le} predicates. */
> +
> +static tree
> +altivec_build_new_resolved_builtin (tree *args, int n, tree fntype,
> +				    tree ret_type,
> +				    rs6000_gen_builtins bif_id,
> +				    rs6000_gen_builtins ovld_id)
> +{
> +  tree argtypes = TYPE_ARG_TYPES (fntype);
> +  tree arg_type[MAX_OVLD_ARGS];
> +  tree fndecl = rs6000_builtin_decls_x[bif_id];
> +  tree call;
> +
> +  for (int i = 0; i < n; i++)
> +    arg_type[i] = TREE_VALUE (argtypes), argtypes = TREE_CHAIN (argtypes);
> +
> +  /* The AltiVec overloading implementation is overall gross, but this
> +     is particularly disgusting.  The vec_{all,any}_{ge,le} builtins
> +     are completely different for floating-point vs. integer vector
> +     types, because the former has vcmpgefp, but the latter should use
> +     vcmpgtXX.
> +
> +     In practice, the second and third arguments are swapped, and the
> +     condition (LT vs. EQ, which is recognizable by bit 1 of the first
> +     argument) is reversed.  Patch the arguments here before building
> +     the resolved CALL_EXPR.  */
> +  if (n == 3
> +      && ovld_id == RS6000_OVLD_VEC_CMPGE_P
> +      && bif_id != RS6000_BIF_VCMPGEFP_P
> +      && bif_id != RS6000_BIF_XVCMPGEDP_P)
> +    {
> +      std::swap (args[1], args[2]);
> +      std::swap (arg_type[1], arg_type[2]);
> +
> +      args[0] = fold_build2 (BIT_XOR_EXPR, TREE_TYPE (args[0]), args[0],
> +			     build_int_cst (NULL_TREE, 2));
> +    }
> +
> +  /* If the number of arguments to an overloaded function increases,
> +     we must expand this switch.  */
> +  gcc_assert (MAX_OVLD_ARGS <= 4);

Ok.   


> +
> +  switch (n)
> +    {
> +    case 0:
> +      call = build_call_expr (fndecl, 0);
> +      break;
> +    case 1:
> +      call = build_call_expr (fndecl, 1,
> +			      fully_fold_convert (arg_type[0], args[0]));
> +      break;
> +    case 2:
> +      call = build_call_expr (fndecl, 2,
> +			      fully_fold_convert (arg_type[0], args[0]),
> +			      fully_fold_convert (arg_type[1], args[1]));
> +      break;
> +    case 3:
> +      call = build_call_expr (fndecl, 3,
> +			      fully_fold_convert (arg_type[0], args[0]),
> +			      fully_fold_convert (arg_type[1], args[1]),
> +			      fully_fold_convert (arg_type[2], args[2]));
> +      break;
> +    case 4:
> +      call = build_call_expr (fndecl, 4,
> +			      fully_fold_convert (arg_type[0], args[0]),
> +			      fully_fold_convert (arg_type[1], args[1]),
> +			      fully_fold_convert (arg_type[2], args[2]),
> +			      fully_fold_convert (arg_type[3], args[3]));
> +      break;
> +    default:
> +      gcc_unreachable ();
> +    }
> +  return fold_convert (ret_type, call);
> +}
> +
> +/* Implementation of the resolve_overloaded_builtin target hook, to
> +   support Altivec's overloaded builtins.  */
> +
> +static tree
> +altivec_resolve_new_overloaded_builtin (location_t loc, tree fndecl,
> +					void *passed_arglist)
> +{
> +  vec<tree, va_gc> *arglist = static_cast<vec<tree, va_gc> *> (passed_arglist);
> +  unsigned int nargs = vec_safe_length (arglist);
> +  enum rs6000_gen_builtins fcode
> +    = (enum rs6000_gen_builtins) DECL_MD_FUNCTION_CODE (fndecl);
> +  tree fnargs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
> +  tree types[MAX_OVLD_ARGS], args[MAX_OVLD_ARGS];
> +  unsigned int n;
> +
> +  /* Return immediately if this isn't an overload.  */
> +  if (fcode <= RS6000_OVLD_NONE)
> +    return NULL_TREE;
> +
> +  unsigned int adj_fcode = fcode - RS6000_OVLD_NONE;
> +
> +  if (TARGET_DEBUG_BUILTIN)
> +    fprintf (stderr, "altivec_resolve_overloaded_builtin, code = %4d, %s\n",
> +	     (int) fcode, IDENTIFIER_POINTER (DECL_NAME (fndecl)));
> +
> +  /* vec_lvsl and vec_lvsr are deprecated for use with LE element order.  */
> +  if (fcode == RS6000_OVLD_VEC_LVSL && !BYTES_BIG_ENDIAN)
> +    warning (OPT_Wdeprecated,
> +	     "%<vec_lvsl%> is deprecated for little endian; use "
> +	     "assignment for unaligned loads and stores");
> +  else if (fcode == RS6000_OVLD_VEC_LVSR && !BYTES_BIG_ENDIAN)
> +    warning (OPT_Wdeprecated,
> +	     "%<vec_lvsr%> is deprecated for little endian; use "
> +	     "assignment for unaligned loads and stores");
> +
> +  if (fcode == RS6000_OVLD_VEC_MUL)
> +    {
> +      /* vec_mul needs to be special cased because there are no instructions
> +	 for it for the {un}signed char, {un}signed short, and {un}signed int
> +	 types.  */
> +      if (nargs != 2)
> +	{
> +	  error ("builtin %qs only accepts 2 arguments", "vec_mul");
> +	  return error_mark_node;
> +	}
> +
> +      tree arg0 = (*arglist)[0];
> +      tree arg0_type = TREE_TYPE (arg0);
> +      tree arg1 = (*arglist)[1];
> +      tree arg1_type = TREE_TYPE (arg1);
> +
> +      /* Both arguments must be vectors and the types must be compatible.  */
> +      if (TREE_CODE (arg0_type) != VECTOR_TYPE)
> +	goto bad;
> +      if (!lang_hooks.types_compatible_p (arg0_type, arg1_type))
> +	goto bad;
> +
> +      switch (TYPE_MODE (TREE_TYPE (arg0_type)))
> +	{
> +	  case E_QImode:
> +	  case E_HImode:
> +	  case E_SImode:
> +	  case E_DImode:
> +	  case E_TImode:
> +	    {
> +	      /* For scalar types just use a multiply expression.  */
> +	      return fold_build2_loc (loc, MULT_EXPR, TREE_TYPE (arg0), arg0,
> +				      fold_convert (TREE_TYPE (arg0), arg1));
> +	    }
> +	  case E_SFmode:
> +	    {
> +	      /* For floats use the xvmulsp instruction directly.  */
> +	      tree call = rs6000_builtin_decls_x[RS6000_BIF_XVMULSP];
> +	      return build_call_expr (call, 2, arg0, arg1);
> +	    }
> +	  case E_DFmode:
> +	    {
> +	      /* For doubles use the xvmuldp instruction directly.  */
> +	      tree call = rs6000_builtin_decls_x[RS6000_BIF_XVMULDP];
> +	      return build_call_expr (call, 2, arg0, arg1);
> +	    }
> +	  /* Other types are errors.  */
> +	  default:
> +	    goto bad;
> +	}
> +    }
> +
> +  if (fcode == RS6000_OVLD_VEC_CMPNE)
> +    {
> +      /* vec_cmpne needs to be special cased because there are no instructions
> +	 for it (prior to power 9).  */
> +      if (nargs != 2)
> +	{
> +	  error ("builtin %qs only accepts 2 arguments", "vec_cmpne");
> +	  return error_mark_node;
> +	}
> +
> +      tree arg0 = (*arglist)[0];
> +      tree arg0_type = TREE_TYPE (arg0);
> +      tree arg1 = (*arglist)[1];
> +      tree arg1_type = TREE_TYPE (arg1);
> +
> +      /* Both arguments must be vectors and the types must be compatible.  */
> +      if (TREE_CODE (arg0_type) != VECTOR_TYPE)
> +	goto bad;
> +      if (!lang_hooks.types_compatible_p (arg0_type, arg1_type))
> +	goto bad;
> +
> +      /* Power9 instructions provide the most efficient implementation of
> +	 ALTIVEC_BUILTIN_VEC_CMPNE if the mode is not DImode or TImode
> +	 or SFmode or DFmode.  */
> +      if (!TARGET_P9_VECTOR
> +	  || (TYPE_MODE (TREE_TYPE (arg0_type)) == DImode)
> +	  || (TYPE_MODE (TREE_TYPE (arg0_type)) == TImode)
> +	  || (TYPE_MODE (TREE_TYPE (arg0_type)) == SFmode)
> +	  || (TYPE_MODE (TREE_TYPE (arg0_type)) == DFmode))
> +	{
> +	  switch (TYPE_MODE (TREE_TYPE (arg0_type)))
> +	    {
> +	      /* vec_cmpneq (va, vb) == vec_nor (vec_cmpeq (va, vb),
> +		 vec_cmpeq (va, vb)).  */
> +	      /* Note:  vec_nand also works but opt changes vec_nand's
> +		 to vec_nor's anyway.  */
> +	    case E_QImode:
> +	    case E_HImode:
> +	    case E_SImode:
> +	    case E_DImode:
> +	    case E_TImode:
> +	    case E_SFmode:
> +	    case E_DFmode:
> +	      {
> +		/* call = vec_cmpeq (va, vb)
> +		   result = vec_nor (call, call).  */
> +		vec<tree, va_gc> *params = make_tree_vector ();
> +		vec_safe_push (params, arg0);
> +		vec_safe_push (params, arg1);
> +		tree call = altivec_resolve_new_overloaded_builtin
> +		  (loc, rs6000_builtin_decls_x[RS6000_OVLD_VEC_CMPEQ],
> +		   params);
> +		/* Use save_expr to ensure that operands used more than once
> +		   that may have side effects (like calls) are only evaluated
> +		   once.  */
> +		call = save_expr (call);
> +		params = make_tree_vector ();
> +		vec_safe_push (params, call);
> +		vec_safe_push (params, call);
> +		return altivec_resolve_new_overloaded_builtin
> +		  (loc, rs6000_builtin_decls_x[RS6000_OVLD_VEC_NOR], params);
> +	      }
> +	      /* Other types are errors.  */
> +	    default:
> +	      goto bad;
> +	    }
> +	}
> +      /* else, fall through and process the Power9 alternative below */
> +    }
> +
> +  if (fcode == RS6000_OVLD_VEC_ADDE || fcode == RS6000_OVLD_VEC_SUBE)
> +    {
> +      /* vec_adde needs to be special cased because there is no instruction
> +	  for the {un}signed int version.  */
> +      if (nargs != 3)
> +	{
> +	  const char *name;
> +	  name = fcode == RS6000_OVLD_VEC_ADDE ? "vec_adde" : "vec_sube";
> +	  error ("builtin %qs only accepts 3 arguments", name);
> +	  return error_mark_node;
> +	}
> +
> +      tree arg0 = (*arglist)[0];
> +      tree arg0_type = TREE_TYPE (arg0);
> +      tree arg1 = (*arglist)[1];
> +      tree arg1_type = TREE_TYPE (arg1);
> +      tree arg2 = (*arglist)[2];
> +      tree arg2_type = TREE_TYPE (arg2);
> +
> +      /* All 3 arguments must be vectors of (signed or unsigned) (int or
> +	 __int128) and the types must be compatible.  */
> +      if (TREE_CODE (arg0_type) != VECTOR_TYPE)
> +	goto bad;
> +      if (!lang_hooks.types_compatible_p (arg0_type, arg1_type)
> +	  || !lang_hooks.types_compatible_p (arg1_type, arg2_type))
> +	goto bad;
> +
> +      switch (TYPE_MODE (TREE_TYPE (arg0_type)))
> +	{
> +	  /* For {un}signed ints,
> +	     vec_adde (va, vb, carryv) == vec_add (vec_add (va, vb),
> +						   vec_and (carryv, 1)).
> +	     vec_sube (va, vb, carryv) == vec_sub (vec_sub (va, vb),
> +						   vec_and (carryv, 1)).  */

Also commented out in the original code.   Since it's dead code, maybe
worth enhancing the comment to clarify why this is disabled?  

> +	  case E_SImode:
> +	    {
> +	      tree add_sub_builtin;
> +
> +	      vec<tree, va_gc> *params = make_tree_vector ();
> +	      vec_safe_push (params, arg0);
> +	      vec_safe_push (params, arg1);
> +
> +	      if (fcode == RS6000_OVLD_VEC_ADDE)
> +		add_sub_builtin = rs6000_builtin_decls_x[RS6000_OVLD_VEC_ADD];
> +	      else
> +		add_sub_builtin = rs6000_builtin_decls_x[RS6000_OVLD_VEC_SUB];
> +
> +	      tree call
> +		= altivec_resolve_new_overloaded_builtin (loc,
> +							  add_sub_builtin,
> +							  params);
> +	      tree const1 = build_int_cstu (TREE_TYPE (arg0_type), 1);
> +	      tree ones_vector = build_vector_from_val (arg0_type, const1);
> +	      tree and_expr = fold_build2_loc (loc, BIT_AND_EXPR, arg0_type,
> +					       arg2, ones_vector);
> +	      params = make_tree_vector ();
> +	      vec_safe_push (params, call);
> +	      vec_safe_push (params, and_expr);
> +	      return altivec_resolve_new_overloaded_builtin (loc,
> +							     add_sub_builtin,
> +							     params);
> +	    }
> +	  /* For {un}signed __int128s use the vaddeuqm/vsubeuqm instruction
> +	     directly.  */
> +	  case E_TImode:
> +	    break;
> +
> +	  /* Types other than {un}signed int and {un}signed __int128
> +		are errors.  */
> +	  default:
> +	    goto bad;
> +	}
> +    }
> +
> +  if (fcode == RS6000_OVLD_VEC_ADDEC || fcode == RS6000_OVLD_VEC_SUBEC)
> +    {
> +      /* vec_addec and vec_subec needs to be special cased because there is
> +	 no instruction for the {un}signed int version.  */
> +      if (nargs != 3)
> +	{
> +	  const char *name;
> +	  name = fcode == RS6000_OVLD_VEC_ADDEC ? "vec_addec" : "vec_subec";
> +	  error ("builtin %qs only accepts 3 arguments", name);
> +	  return error_mark_node;
> +	}
> +
> +      tree arg0 = (*arglist)[0];
> +      tree arg0_type = TREE_TYPE (arg0);
> +      tree arg1 = (*arglist)[1];
> +      tree arg1_type = TREE_TYPE (arg1);
> +      tree arg2 = (*arglist)[2];
> +      tree arg2_type = TREE_TYPE (arg2);
> +
> +      /* All 3 arguments must be vectors of (signed or unsigned) (int or
> +	 __int128) and the types must be compatible.  */
> +      if (TREE_CODE (arg0_type) != VECTOR_TYPE)
> +	goto bad;
> +      if (!lang_hooks.types_compatible_p (arg0_type, arg1_type)
> +	  || !lang_hooks.types_compatible_p (arg1_type, arg2_type))
> +	goto bad;
> +
> +      switch (TYPE_MODE (TREE_TYPE (arg0_type)))
> +	{
> +	  /* For {un}signed ints,
> +	      vec_addec (va, vb, carryv) ==
> +				vec_or (vec_addc (va, vb),
> +					vec_addc (vec_add (va, vb),
> +						  vec_and (carryv, 0x1))).  */

similar here.

> +	  case E_SImode:
> +	    {
> +	    /* Use save_expr to ensure that operands used more than once
> +		that may have side effects (like calls) are only evaluated
> +		once.  */
> +	    tree as_builtin;
> +	    tree as_c_builtin;
> +
> +	    arg0 = save_expr (arg0);
> +	    arg1 = save_expr (arg1);
> +	    vec<tree, va_gc> *params = make_tree_vector ();
> +	    vec_safe_push (params, arg0);
> +	    vec_safe_push (params, arg1);
> +
> +	    if (fcode == RS6000_OVLD_VEC_ADDEC)
> +	      as_c_builtin = rs6000_builtin_decls_x[RS6000_OVLD_VEC_ADDC];
> +	    else
> +	      as_c_builtin = rs6000_builtin_decls_x[RS6000_OVLD_VEC_SUBC];
> +
> +	    tree call1 = altivec_resolve_new_overloaded_builtin (loc,
> +								 as_c_builtin,
> +								 params);
> +	    params = make_tree_vector ();
> +	    vec_safe_push (params, arg0);
> +	    vec_safe_push (params, arg1);
> +
> +

extra blank line?


> +	    if (fcode == RS6000_OVLD_VEC_ADDEC)
> +	      as_builtin = rs6000_builtin_decls_x[RS6000_OVLD_VEC_ADD];
> +	    else
> +	      as_builtin = rs6000_builtin_decls_x[RS6000_OVLD_VEC_SUB];
> +
> +	    tree call2 = altivec_resolve_new_overloaded_builtin (loc,
> +								 as_builtin,
> +								 params);
> +	    tree const1 = build_int_cstu (TREE_TYPE (arg0_type), 1);
> +	    tree ones_vector = build_vector_from_val (arg0_type, const1);
> +	    tree and_expr = fold_build2_loc (loc, BIT_AND_EXPR, arg0_type,
> +					     arg2, ones_vector);
> +	    params = make_tree_vector ();
> +	    vec_safe_push (params, call2);
> +	    vec_safe_push (params, and_expr);
> +	    call2 = altivec_resolve_new_overloaded_builtin (loc, as_c_builtin,
> +							    params);
> +	    params = make_tree_vector ();
> +	    vec_safe_push (params, call1);
> +	    vec_safe_push (params, call2);
> +	    tree or_builtin = rs6000_builtin_decls_x[RS6000_OVLD_VEC_OR];
> +	    return altivec_resolve_new_overloaded_builtin (loc, or_builtin,
> +							   params);
> +	    }
> +	  /* For {un}signed __int128s use the vaddecuq/vsubbecuq
> +	     instructions.  This occurs through normal processing.  */
> +	  case E_TImode:
> +	    break;
> +
> +	  /* Types other than {un}signed int and {un}signed __int128
> +		are errors.  */
> +	  default:
> +	    goto bad;
> +	}
> +    }

ok

> +
> +  /* For now treat vec_splats and vec_promote as the same.  */
> +  if (fcode == RS6000_OVLD_VEC_SPLATS || fcode == RS6000_OVLD_VEC_PROMOTE)
> +    {
> +      tree type, arg;
> +      int size;
> +      int i;
> +      bool unsigned_p;
> +      vec<constructor_elt, va_gc> *vec;
> +      const char *name;
> +      name = fcode == RS6000_OVLD_VEC_SPLATS ? "vec_splats" : "vec_promote";
> +
> +      if (fcode == RS6000_OVLD_VEC_SPLATS && nargs != 1)
> +	{
> +	  error ("builtin %qs only accepts 1 argument", name);
> +	  return error_mark_node;
> +	}
> +      if (fcode == RS6000_OVLD_VEC_PROMOTE && nargs != 2)
> +	{
> +	  error ("builtin %qs only accepts 2 arguments", name);
> +	  return error_mark_node;
> +	}
> +      /* Ignore promote's element argument.  */
> +      if (fcode == RS6000_OVLD_VEC_PROMOTE
> +	  && !INTEGRAL_TYPE_P (TREE_TYPE ((*arglist)[1])))
> +	goto bad;
> +
> +      arg = (*arglist)[0];
> +      type = TREE_TYPE (arg);
> +      if (!SCALAR_FLOAT_TYPE_P (type)
> +	  && !INTEGRAL_TYPE_P (type))
> +	goto bad;
> +      unsigned_p = TYPE_UNSIGNED (type);
> +      switch (TYPE_MODE (type))
> +	{
> +	  case E_TImode:
> +	    type = (unsigned_p ? unsigned_V1TI_type_node : V1TI_type_node);
> +	    size = 1;
> +	    break;
> +	  case E_DImode:
> +	    type = (unsigned_p ? unsigned_V2DI_type_node : V2DI_type_node);
> +	    size = 2;
> +	    break;
> +	  case E_SImode:
> +	    type = (unsigned_p ? unsigned_V4SI_type_node : V4SI_type_node);
> +	    size = 4;
> +	    break;
> +	  case E_HImode:
> +	    type = (unsigned_p ? unsigned_V8HI_type_node : V8HI_type_node);
> +	    size = 8;
> +	    break;
> +	  case E_QImode:
> +	    type = (unsigned_p ? unsigned_V16QI_type_node : V16QI_type_node);
> +	    size = 16;
> +	    break;
> +	  case E_SFmode:
> +	    type = V4SF_type_node;
> +	    size = 4;
> +	    break;
> +	  case E_DFmode:
> +	    type = V2DF_type_node;
> +	    size = 2;
> +	    break;
> +	  default:
> +	    goto bad;
> +	}
> +      arg = save_expr (fold_convert (TREE_TYPE (type), arg));
> +      vec_alloc (vec, size);
> +      for (i = 0; i < size; i++)
> +	{
> +	  constructor_elt elt = {NULL_TREE, arg};
> +	  vec->quick_push (elt);
> +	}
> +      return build_constructor (type, vec);
> +    }
> +
> +  /* For now use pointer tricks to do the extraction, unless we are on VSX
> +     extracting a double from a constant offset.  */
> +  if (fcode == RS6000_OVLD_VEC_EXTRACT)
> +    {
> +      tree arg1;
> +      tree arg1_type;
> +      tree arg2;
> +      tree arg1_inner_type;
> +      tree decl, stmt;
> +      tree innerptrtype;
> +      machine_mode mode;
> +
> +      /* No second argument. */
> +      if (nargs != 2)
> +	{
> +	  error ("builtin %qs only accepts 2 arguments", "vec_extract");
> +	  return error_mark_node;
> +	}
> +
> +      arg2 = (*arglist)[1];
> +      arg1 = (*arglist)[0];
> +      arg1_type = TREE_TYPE (arg1);
> +
> +      if (TREE_CODE (arg1_type) != VECTOR_TYPE)
> +	goto bad;
> +      if (!INTEGRAL_TYPE_P (TREE_TYPE (arg2)))
> +	goto bad;
> +
> +      /* See if we can optimize vec_extracts with the current VSX instruction
> +	 set.  */
> +      mode = TYPE_MODE (arg1_type);
> +      if (VECTOR_MEM_VSX_P (mode))
> +
> +	{
> +	  tree call = NULL_TREE;
> +	  int nunits = GET_MODE_NUNITS (mode);
> +
> +	  arg2 = fold_for_warn (arg2);
> +
> +	  /* If the second argument is an integer constant, generate
> +	     the built-in code if we can.  We need 64-bit and direct
> +	     move to extract the small integer vectors.  */
> +	  if (TREE_CODE (arg2) == INTEGER_CST)
> +	    {
> +	      wide_int selector = wi::to_wide (arg2);
> +	      selector = wi::umod_trunc (selector, nunits);
> +	      arg2 = wide_int_to_tree (TREE_TYPE (arg2), selector);
> +	      switch (mode)
> +		{
> +		default:
> +		  break;
> +
> +		case E_V1TImode:
> +		  call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V1TI];
> +		  break;
> +
> +		case E_V2DFmode:
> +		  call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V2DF];
> +		  break;
> +
> +		case E_V2DImode:
> +		  call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V2DI];
> +		  break;
> +
> +		case E_V4SFmode:
> +		  call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V4SF];
> +		  break;
> +
> +		case E_V4SImode:
> +		  if (TARGET_DIRECT_MOVE_64BIT)
> +		    call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V4SI];
> +		  break;
> +
> +		case E_V8HImode:
> +		  if (TARGET_DIRECT_MOVE_64BIT)
> +		    call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V8HI];
> +		  break;
> +
> +		case E_V16QImode:
> +		  if (TARGET_DIRECT_MOVE_64BIT)
> +		    call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V16QI];
> +		  break;
> +		}
> +	    }
> +
> +	  /* If the second argument is variable, we can optimize it if we are
> +	     generating 64-bit code on a machine with direct move.  */
> +	  else if (TREE_CODE (arg2) != INTEGER_CST && TARGET_DIRECT_MOVE_64BIT)
> +	    {
> +	      switch (mode)
> +		{
> +		default:
> +		  break;
> +
> +		case E_V2DFmode:
> +		  call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V2DF];
> +		  break;
> +
> +		case E_V2DImode:
> +		  call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V2DI];
> +		  break;
> +
> +		case E_V4SFmode:
> +		  call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V4SF];
> +		  break;
> +
> +		case E_V4SImode:
> +		  call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V4SI];
> +		  break;
> +
> +		case E_V8HImode:
> +		  call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V8HI];
> +		  break;
> +
> +		case E_V16QImode:
> +		  call = rs6000_builtin_decls_x[RS6000_BIF_VEC_EXT_V16QI];
> +		  break;
> +		}
> +	    }
> +
> +	  if (call)
> +	    {
> +	      tree result = build_call_expr (call, 2, arg1, arg2);
> +	      /* Coerce the result to vector element type.  May be no-op.  */
> +	      arg1_inner_type = TREE_TYPE (arg1_type);
> +	      result = fold_convert (arg1_inner_type, result);
> +	      return result;
> +	    }
> +	}
> +
> +      /* Build *(((arg1_inner_type*)&(vector type){arg1})+arg2). */
> +      arg1_inner_type = TREE_TYPE (arg1_type);
> +      arg2 = build_binary_op (loc, BIT_AND_EXPR, arg2,
> +			      build_int_cst (TREE_TYPE (arg2),
> +					     TYPE_VECTOR_SUBPARTS (arg1_type)
> +					     - 1), 0);
> +      decl = build_decl (loc, VAR_DECL, NULL_TREE, arg1_type);
> +      DECL_EXTERNAL (decl) = 0;
> +      TREE_PUBLIC (decl) = 0;
> +      DECL_CONTEXT (decl) = current_function_decl;
> +      TREE_USED (decl) = 1;
> +      TREE_TYPE (decl) = arg1_type;
> +      TREE_READONLY (decl) = TYPE_READONLY (arg1_type);
> +      if (c_dialect_cxx ())
> +	{
> +	  stmt = build4 (TARGET_EXPR, arg1_type, decl, arg1,
> +			 NULL_TREE, NULL_TREE);
> +	  SET_EXPR_LOCATION (stmt, loc);
> +	}
> +      else
> +	{
> +	  DECL_INITIAL (decl) = arg1;
> +	  stmt = build1 (DECL_EXPR, arg1_type, decl);
> +	  TREE_ADDRESSABLE (decl) = 1;
> +	  SET_EXPR_LOCATION (stmt, loc);
> +	  stmt = build1 (COMPOUND_LITERAL_EXPR, arg1_type, stmt);
> +	}
> +
> +      innerptrtype = build_pointer_type (arg1_inner_type);
> +
> +      stmt = build_unary_op (loc, ADDR_EXPR, stmt, 0);
> +      stmt = convert (innerptrtype, stmt);
> +      stmt = build_binary_op (loc, PLUS_EXPR, stmt, arg2, 1);
> +      stmt = build_indirect_ref (loc, stmt, RO_NULL);
> +
> +      /* PR83660: We mark this as having side effects so that
> +	 downstream in fold_build_cleanup_point_expr () it will get a
> +	 CLEANUP_POINT_EXPR.  If it does not we can run into an ICE
> +	 later in gimplify_cleanup_point_expr ().  Potentially this
> +	 causes missed optimization because there actually is no side
> +	 effect.  */
> +      if (c_dialect_cxx ())
> +	TREE_SIDE_EFFECTS (stmt) = 1;
> +
> +      return stmt;
> +    }

ok

> +
> +  /* For now use pointer tricks to do the insertion, unless we are on VSX
> +     inserting a double to a constant offset..  */

Too many ending periods. :-)   (also in original)

> +  if (fcode == RS6000_OVLD_VEC_INSERT)
> +    {
> +      tree arg0;
> +      tree arg1;
> +      tree arg2;
> +      tree arg1_type;
> +      tree decl, stmt;
> +      machine_mode mode;
> +
> +      /* No second or third arguments. */
> +      if (nargs != 3)
> +	{
> +	  error ("builtin %qs only accepts 3 arguments", "vec_insert");
> +	  return error_mark_node;
> +	}
> +
> +      arg0 = (*arglist)[0];
> +      arg1 = (*arglist)[1];
> +      arg1_type = TREE_TYPE (arg1);
> +      arg2 = fold_for_warn ((*arglist)[2]);
> +
> +      if (TREE_CODE (arg1_type) != VECTOR_TYPE)
> +	goto bad;
> +      if (!INTEGRAL_TYPE_P (TREE_TYPE (arg2)))
> +	goto bad;
> +
> +      /* If we can use the VSX xxpermdi instruction, use that for insert.  */
> +      mode = TYPE_MODE (arg1_type);
> +      if ((mode == V2DFmode || mode == V2DImode) && VECTOR_UNIT_VSX_P (mode)
> +	  && TREE_CODE (arg2) == INTEGER_CST)
> +	{
> +	  wide_int selector = wi::to_wide (arg2);
> +	  selector = wi::umod_trunc (selector, 2);
> +	  tree call = NULL_TREE;
> +
> +	  arg2 = wide_int_to_tree (TREE_TYPE (arg2), selector);
> +	  if (mode == V2DFmode)
> +	    call = rs6000_builtin_decls_x[RS6000_BIF_VEC_SET_V2DF];
> +	  else if (mode == V2DImode)
> +	    call = rs6000_builtin_decls_x[RS6000_BIF_VEC_SET_V2DI];
> +
> +	  /* Note, __builtin_vec_insert_<xxx> has vector and scalar types
> +	     reversed.  */
> +	  if (call)
> +	    return build_call_expr (call, 3, arg1, arg0, arg2);
> +	}
> +      else if (mode == V1TImode && VECTOR_UNIT_VSX_P (mode)
> +	       && TREE_CODE (arg2) == INTEGER_CST)
> +	{
> +	  tree call = rs6000_builtin_decls_x[RS6000_BIF_VEC_SET_V1TI];
> +	  wide_int selector = wi::zero(32);
> +
> +	  arg2 = wide_int_to_tree (TREE_TYPE (arg2), selector);
> +	  /* Note, __builtin_vec_insert_<xxx> has vector and scalar types
> +	     reversed.  */
> +	  return build_call_expr (call, 3, arg1, arg0, arg2);
> +	}
> +
> +      /* Build *(((arg1_inner_type*)&(vector type){arg1})+arg2) = arg0 with
> +	 VIEW_CONVERT_EXPR.  i.e.:
> +	 D.3192 = v1;
> +	 _1 = n & 3;
> +	 VIEW_CONVERT_EXPR<int[4]>(D.3192)[_1] = i;
> +	 v1 = D.3192;
> +	 D.3194 = v1;  */
> +      if (TYPE_VECTOR_SUBPARTS (arg1_type) == 1)
> +	arg2 = build_int_cst (TREE_TYPE (arg2), 0);
> +      else
> +	arg2 = build_binary_op (loc, BIT_AND_EXPR, arg2,
> +				build_int_cst (TREE_TYPE (arg2),
> +					       TYPE_VECTOR_SUBPARTS (arg1_type)
> +					       - 1), 0);
> +      decl = build_decl (loc, VAR_DECL, NULL_TREE, arg1_type);
> +      DECL_EXTERNAL (decl) = 0;
> +      TREE_PUBLIC (decl) = 0;
> +      DECL_CONTEXT (decl) = current_function_decl;
> +      TREE_USED (decl) = 1;
> +      TREE_TYPE (decl) = arg1_type;
> +      TREE_READONLY (decl) = TYPE_READONLY (arg1_type);
> +      TREE_ADDRESSABLE (decl) = 1;
> +      if (c_dialect_cxx ())
> +	{
> +	  stmt = build4 (TARGET_EXPR, arg1_type, decl, arg1,
> +			 NULL_TREE, NULL_TREE);
> +	  SET_EXPR_LOCATION (stmt, loc);
> +	}
> +      else
> +	{
> +	  DECL_INITIAL (decl) = arg1;
> +	  stmt = build1 (DECL_EXPR, arg1_type, decl);
> +	  SET_EXPR_LOCATION (stmt, loc);
> +	  stmt = build1 (COMPOUND_LITERAL_EXPR, arg1_type, stmt);
> +	}
> +
> +      if (TARGET_VSX)
> +	{
> +	  stmt = build_array_ref (loc, stmt, arg2);
> +	  stmt = fold_build2 (MODIFY_EXPR, TREE_TYPE (arg0), stmt,
> +			      convert (TREE_TYPE (stmt), arg0));
> +	  stmt = build2 (COMPOUND_EXPR, arg1_type, stmt, decl);
> +	}
> +      else
> +	{
> +	  tree arg1_inner_type;
> +	  tree innerptrtype;
> +	  arg1_inner_type = TREE_TYPE (arg1_type);
> +	  innerptrtype = build_pointer_type (arg1_inner_type);
> +
> +	  stmt = build_unary_op (loc, ADDR_EXPR, stmt, 0);
> +	  stmt = convert (innerptrtype, stmt);
> +	  stmt = build_binary_op (loc, PLUS_EXPR, stmt, arg2, 1);
> +	  stmt = build_indirect_ref (loc, stmt, RO_NULL);
> +	  stmt = build2 (MODIFY_EXPR, TREE_TYPE (stmt), stmt,
> +			 convert (TREE_TYPE (stmt), arg0));
> +	  stmt = build2 (COMPOUND_EXPR, arg1_type, stmt, decl);
> +	}
> +      return stmt;
> +    }
> +
> +  for (n = 0;
> +       !VOID_TYPE_P (TREE_VALUE (fnargs)) && n < nargs;
> +       fnargs = TREE_CHAIN (fnargs), n++)
> +    {
> +      tree decl_type = TREE_VALUE (fnargs);
> +      tree arg = (*arglist)[n];
> +      tree type;
> +
> +      if (arg == error_mark_node)
> +	return error_mark_node;
> +
> +      if (n >= MAX_OVLD_ARGS)
> +	abort ();
> +
> +      arg = default_conversion (arg);
> +
> +      /* The C++ front-end converts float * to const void * using
> +	 NOP_EXPR<const void *> (NOP_EXPR<void *> (x)).  */
> +      type = TREE_TYPE (arg);
> +      if (POINTER_TYPE_P (type)
> +	  && TREE_CODE (arg) == NOP_EXPR
> +	  && lang_hooks.types_compatible_p (TREE_TYPE (arg),
> +					    const_ptr_type_node)
> +	  && lang_hooks.types_compatible_p (TREE_TYPE (TREE_OPERAND (arg, 0)),
> +					    ptr_type_node))
> +	{
> +	  arg = TREE_OPERAND (arg, 0);
> +	  type = TREE_TYPE (arg);
> +	}
> +
> +      /* Remove the const from the pointers to simplify the overload
> +	 matching further down.  */
> +      if (POINTER_TYPE_P (decl_type)
> +	  && POINTER_TYPE_P (type)
> +	  && TYPE_QUALS (TREE_TYPE (type)) != 0)
> +	{
> +	  if (TYPE_READONLY (TREE_TYPE (type))
> +	      && !TYPE_READONLY (TREE_TYPE (decl_type)))
> +	    warning (0, "passing argument %d of %qE discards qualifiers from "
> +		     "pointer target type", n + 1, fndecl);
> +	  type = build_pointer_type (build_qualified_type (TREE_TYPE (type),
> +							   0));
> +	  arg = fold_convert (type, arg);
> +	}
> +
> +      /* For RS6000_OVLD_VEC_LXVL, convert any const * to its non constant
> +	 equivalent to simplify the overload matching below.  */
> +      if (fcode == RS6000_OVLD_VEC_LXVL)
> +	{
> +	  if (POINTER_TYPE_P (type)
> +	      && TYPE_READONLY (TREE_TYPE (type)))
> +	    {
> +	      type = build_pointer_type (build_qualified_type (
> +						TREE_TYPE (type),0));
> +	      arg = fold_convert (type, arg);
> +	    }
> +	}
> +
> +      args[n] = arg;
> +      types[n] = type;
> +    }
> +
> +  /* If the number of arguments did not match the prototype, return NULL
> +     and the generic code will issue the appropriate error message.  */
> +  if (!VOID_TYPE_P (TREE_VALUE (fnargs)) || n < nargs)
> +    return NULL;
> +
> +  if (fcode == RS6000_OVLD_VEC_STEP)
> +    {
> +      if (TREE_CODE (types[0]) != VECTOR_TYPE)
> +	goto bad;
> +
> +      return build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (types[0]));
> +    }
> +
> +  {
> +    bool unsupported_builtin = false;
> +    enum rs6000_gen_builtins overloaded_code;
> +    bool supported = false;
> +    ovlddata *instance = rs6000_overload_info[adj_fcode].first_instance;
> +    gcc_assert (instance != NULL);
> +
> +    /* Need to special case __builtin_cmpb because the overloaded forms
> +       of this function take (unsigned int, unsigned int) or (unsigned
> +       long long int, unsigned long long int).  Since C conventions
> +       allow the respective argument types to be implicitly coerced into
> +       each other, the default handling does not provide adequate
> +       discrimination between the desired forms of the function.  */
> +    if (fcode == RS6000_OVLD_SCAL_CMPB)
> +      {
> +	machine_mode arg1_mode = TYPE_MODE (types[0]);
> +	machine_mode arg2_mode = TYPE_MODE (types[1]);
> +
> +	if (nargs != 2)
> +	  {
> +	    error ("builtin %qs only accepts 2 arguments", "__builtin_cmpb");
> +	    return error_mark_node;
> +	  }
> +
> +	/* If any supplied arguments are wider than 32 bits, resolve to
> +	   64-bit variant of built-in function.  */
> +	if ((GET_MODE_PRECISION (arg1_mode) > 32)
> +	    || (GET_MODE_PRECISION (arg2_mode) > 32))
> +	  {
> +	    /* Assure all argument and result types are compatible with
> +	       the built-in function represented by RS6000_BIF_CMPB.  */
> +	    overloaded_code = RS6000_BIF_CMPB;
> +	  }
> +	else
> +	  {
> +	    /* Assure all argument and result types are compatible with
> +	       the built-in function represented by RS6000_BIF_CMPB_32.  */
> +	    overloaded_code = RS6000_BIF_CMPB_32;
> +	  }
> +
> +	while (instance && instance->bifid != overloaded_code)
> +	  instance = instance->next;
> +
> +	gcc_assert (instance != NULL);
> +	tree fntype = rs6000_builtin_info_x[instance->bifid].fntype;
> +	tree parmtype0 = TREE_VALUE (TYPE_ARG_TYPES (fntype));
> +	tree parmtype1 = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (fntype)));
> +
> +	if (rs6000_new_builtin_type_compatible (types[0], parmtype0)
> +	    && rs6000_new_builtin_type_compatible (types[1], parmtype1))
> +	  {
> +	    if (rs6000_builtin_decl (instance->bifid, false) != error_mark_node
> +		&& rs6000_new_builtin_is_supported (instance->bifid))
> +	      {
> +		tree ret_type = TREE_TYPE (instance->fntype);
> +		return altivec_build_new_resolved_builtin (args, n, fntype,
> +							   ret_type,
> +							   instance->bifid,
> +							   fcode);
> +	      }
> +	    else
> +	      unsupported_builtin = true;
> +	  }
> +      }
> +    else if (fcode == RS6000_OVLD_VEC_VSIE)

OK, noting that this is foo_VEC_VSIEDP in the original code. (DP
indicator dropped).


> +      {
> +	machine_mode arg1_mode = TYPE_MODE (types[0]);
> +
> +	if (nargs != 2)
> +	  {
> +	    error ("builtin %qs only accepts 2 arguments",
> +		   "scalar_insert_exp");
> +	    return error_mark_node;
> +	  }
> +
> +	/* If supplied first argument is wider than 64 bits, resolve to
> +	   128-bit variant of built-in function.  */
> +	if (GET_MODE_PRECISION (arg1_mode) > 64)
> +	  {
> +	    /* If first argument is of float variety, choose variant
> +	       that expects __ieee128 argument.  Otherwise, expect
> +	       __int128 argument.  */

Could use some "a" and/or "the" in the comment there.   similar below. 
This matches comment in original code, so nbd. :-)


> +	    if (GET_MODE_CLASS (arg1_mode) == MODE_FLOAT)
> +	      overloaded_code = RS6000_BIF_VSIEQPF;
> +	    else
> +	      overloaded_code = RS6000_BIF_VSIEQP;
> +	  }
> +	else
> +	  {
> +	    /* If first argument is of float variety, choose variant
> +	       that expects double argument.  Otherwise, expect
> +	       long long int argument.  */
> +	    if (GET_MODE_CLASS (arg1_mode) == MODE_FLOAT)
> +	      overloaded_code = RS6000_BIF_VSIEDPF;
> +	    else
> +	      overloaded_code = RS6000_BIF_VSIEDP;
> +	  }
> +
> +	while (instance && instance->bifid != overloaded_code)
> +	  instance = instance->next;
> +
> +	gcc_assert (instance != NULL);
> +	tree fntype = rs6000_builtin_info_x[instance->bifid].fntype;
> +	tree parmtype0 = TREE_VALUE (TYPE_ARG_TYPES (fntype));
> +	tree parmtype1 = TREE_VALUE (TREE_CHAIN (TYPE_ARG_TYPES (fntype)));
> +
> +	if (rs6000_new_builtin_type_compatible (types[0], parmtype0)
> +	    && rs6000_new_builtin_type_compatible (types[1], parmtype1))
> +	  {
> +	    if (rs6000_builtin_decl (instance->bifid, false) != error_mark_node
> +		&& rs6000_new_builtin_is_supported (instance->bifid))
> +	      {
> +		tree ret_type = TREE_TYPE (instance->fntype);
> +		return altivec_build_new_resolved_builtin (args, n, fntype,
> +							   ret_type,
> +							   instance->bifid,
> +							   fcode);
> +	      }
> +	    else
> +	      unsupported_builtin = true;
> +	  }
> +      }
> +    else
> +      {
> +	/* Functions with no arguments can have only one overloaded
> +	   instance.  */
> +	gcc_assert (n > 0 || !instance->next);
> +
> +	for (; instance != NULL; instance = instance->next)
> +	  {
> +	    bool mismatch = false;
> +	    tree nextparm = TYPE_ARG_TYPES (instance->fntype);
> +
> +	    for (unsigned int arg_i = 0;
> +		 arg_i < nargs && nextparm != NULL;
> +		 arg_i++)
> +	      {
> +		tree parmtype = TREE_VALUE (nextparm);
> +		if (!rs6000_new_builtin_type_compatible (types[arg_i],
> +							 parmtype))
> +		  {
> +		    mismatch = true;
> +		    break;
> +		  }
> +		nextparm = TREE_CHAIN (nextparm);
> +	      }
> +
> +	    if (mismatch)
> +	      continue;
> +
> +	    supported = rs6000_new_builtin_is_supported (instance->bifid);
> +	    if (rs6000_builtin_decl (instance->bifid, false) != error_mark_node
> +		&& supported)
> +	      {
> +		tree fntype = rs6000_builtin_info_x[instance->bifid].fntype;
> +		tree ret_type = TREE_TYPE (instance->fntype);
> +		return altivec_build_new_resolved_builtin (args, n, fntype,
> +							   ret_type,
> +							   instance->bifid,
> +							   fcode);
> +	      }
> +	    else
> +	      {
> +		unsupported_builtin = true;
> +		break;
> +	      }
> +	  }
> +      }
> +
> +    if (unsupported_builtin)
> +      {
> +	const char *name = rs6000_overload_info[adj_fcode].ovld_name;
> +	if (!supported)
> +	  {
> +	    const char *internal_name
> +	      = rs6000_builtin_info_x[instance->bifid].bifname;
> +	    /* An error message making reference to the name of the
> +	       non-overloaded function has already been issued.  Add
> +	       clarification of the previous message.  */
> +	    rich_location richloc (line_table, input_location);
> +	    inform (&richloc, "builtin %qs requires builtin %qs",
> +		    name, internal_name);
> +	  }
> +	else
> +	  error ("%qs is not supported in this compiler configuration", name);
> +	/* If an error-representing  result tree was returned from
> +	   altivec_build_resolved_builtin above, use it.  */

Extra space after error-representing.  Also in original code.


> +	/*
> +	return (result != NULL) ? result : error_mark_node;
> +	*/
> +	return error_mark_node;
> +      }
> +  }
> + bad:
> +  {
> +    const char *name = rs6000_overload_info[adj_fcode].ovld_name;
> +    error ("invalid parameter combination for AltiVec intrinsic %qs", name);
> +    return error_mark_node;
> +  }
> +}

ok


> diff --git a/gcc/config/rs6000/rs6000-call.c b/gcc/config/rs6000/rs6000-call.c
> index e8625d17d18..2c68aa3580c 100644
> --- a/gcc/config/rs6000/rs6000-call.c
> +++ b/gcc/config/rs6000/rs6000-call.c
> @@ -12971,6 +12971,59 @@ rs6000_gimple_fold_builtin (gimple_stmt_iterator *gsi)
>    return false;
>  }
> 
> +/* Check whether a builtin function is supported in this target
> +   configuration.  */
> +bool
> +rs6000_new_builtin_is_supported (enum rs6000_gen_builtins fncode)
> +{
> +  switch (rs6000_builtin_info_x[(size_t) fncode].enable)
> +    {
> +    default:
> +      gcc_unreachable ();
> +    case ENB_ALWAYS:
> +      return true;
> +    case ENB_P5:
> +      return TARGET_POPCNTB;
> +    case ENB_P6:
> +      return TARGET_CMPB;
> +    case ENB_ALTIVEC:
> +      return TARGET_ALTIVEC;
> +    case ENB_CELL:
> +      return TARGET_ALTIVEC && rs6000_cpu == PROCESSOR_CELL;
> +    case ENB_VSX:
> +      return TARGET_VSX;
> +    case ENB_P7:
> +      return TARGET_POPCNTD;
> +    case ENB_P7_64:
> +      return TARGET_POPCNTD && TARGET_POWERPC64;
> +    case ENB_P8:
> +      return TARGET_DIRECT_MOVE;
> +    case ENB_P8V:
> +      return TARGET_P8_VECTOR;
> +    case ENB_P9:
> +      return TARGET_MODULO;
> +    case ENB_P9_64:
> +      return TARGET_MODULO && TARGET_POWERPC64;
> +    case ENB_P9V:
> +      return TARGET_P9_VECTOR;
> +    case ENB_IEEE128_HW:
> +      return TARGET_FLOAT128_HW;
> +    case ENB_DFP:
> +      return TARGET_DFP;
> +    case ENB_CRYPTO:
> +      return TARGET_CRYPTO;
> +    case ENB_HTM:
> +      return TARGET_HTM;
> +    case ENB_P10:
> +      return TARGET_POWER10;
> +    case ENB_P10_64:
> +      return TARGET_POWER10 && TARGET_POWERPC64;
> +    case ENB_MMA:
> +      return TARGET_MMA;
> +    }
> +  gcc_unreachable ();
> +}

ok

> +
>  /* Expand an expression EXP that calls a built-in function,
>     with result going to TARGET if that's convenient
>     (and in mode MODE if that's convenient).
> diff --git a/gcc/config/rs6000/rs6000-gen-builtins.c b/gcc/config/rs6000/rs6000-gen-builtins.c
> index f3d6156400a..f65932e1cd5 100644
> --- a/gcc/config/rs6000/rs6000-gen-builtins.c
> +++ b/gcc/config/rs6000/rs6000-gen-builtins.c
> @@ -2314,7 +2314,7 @@ write_decls (void)
> 
>    fprintf (header_file, "extern void rs6000_init_generated_builtins ();\n\n");
>    fprintf (header_file,
> -	   "extern bool rs6000_new_builtin_is_supported_p "
> +	   "extern bool rs6000_new_builtin_is_supported "
>  	   "(rs6000_gen_builtins);\n");
>    fprintf (header_file,
>  	   "extern tree rs6000_builtin_decl (unsigned, "


ok.

Thanks
-Will