gcc/builtins.c

   1 /* Expand builtin functions.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "machmode.h"
  27 #include "rtl.h"
  28 #include "tree.h"
  29 #include "realmpfr.h"
  30 #include "gimple.h"
  31 #include "flags.h"
  32 #include "regs.h"
  33 #include "hard-reg-set.h"
  34 #include "except.h"
  35 #include "function.h"
  36 #include "insn-config.h"
  37 #include "expr.h"
  38 #include "optabs.h"
  39 #include "libfuncs.h"
  40 #include "recog.h"
  41 #include "output.h"
  42 #include "typeclass.h"
  43 #include "toplev.h"
  44 #include "predict.h"
  45 #include "tm_p.h"
  46 #include "target.h"
  47 #include "langhooks.h"
  48 #include "basic-block.h"
  49 #include "tree-mudflap.h"
  50 #include "tree-flow.h"
  51 #include "value-prof.h"
  52 #include "diagnostic-core.h"
  53 #include "builtins.h"
  54
  55 #ifndef SLOW_UNALIGNED_ACCESS
  56 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
  57 #endif
  58
  59 #ifndef PAD_VARARGS_DOWN
  60 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
  61 #endif
  62 static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));
  63
  64 struct target_builtins default_target_builtins;
  65 #if SWITCHABLE_TARGET
  66 struct target_builtins *this_target_builtins = &default_target_builtins;
  67 #endif
  68
  69 /* Define the names of the builtin function types and codes.  */
  70 const char *const built_in_class_names[4]
  71   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
  72
  73 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
  74 const char * built_in_names[(int) END_BUILTINS] =
  75 {
  76 #include "builtins.def"
  77 };
  78 #undef DEF_BUILTIN
  79
  80 /* Setup an array of _DECL trees, make sure each element is
  81    initialized to NULL_TREE.  */
  82 tree built_in_decls[(int) END_BUILTINS];
  83 /* Declarations used when constructing the builtin implicitly in the compiler.
  84    It may be NULL_TREE when this is invalid (for instance runtime is not
  85    required to implement the function call in all cases).  */
  86 tree implicit_built_in_decls[(int) END_BUILTINS];
  87
  88 static const char *c_getstr (tree);
  89 static rtx c_readstr (const char *, enum machine_mode);
  90 static int target_char_cast (tree, char *);
  91 static rtx get_memory_rtx (tree, tree);
  92 static int apply_args_size (void);
  93 static int apply_result_size (void);
  94 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
  95 static rtx result_vector (int, rtx);
  96 #endif
  97 static void expand_builtin_update_setjmp_buf (rtx);
  98 static void expand_builtin_prefetch (tree);
  99 static rtx expand_builtin_apply_args (void);
 100 static rtx expand_builtin_apply_args_1 (void);
 101 static rtx expand_builtin_apply (rtx, rtx, rtx);
 102 static void expand_builtin_return (rtx);
 103 static enum type_class type_to_class (tree);
 104 static rtx expand_builtin_classify_type (tree);
 105 static void expand_errno_check (tree, rtx);
 106 static rtx expand_builtin_mathfn (tree, rtx, rtx);
 107 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
 108 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
 109 static rtx expand_builtin_interclass_mathfn (tree, rtx, rtx);
 110 static rtx expand_builtin_sincos (tree);
 111 static rtx expand_builtin_cexpi (tree, rtx, rtx);
 112 static rtx expand_builtin_int_roundingfn (tree, rtx);
 113 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
 114 static rtx expand_builtin_next_arg (void);
 115 static rtx expand_builtin_va_start (tree);
 116 static rtx expand_builtin_va_end (tree);
 117 static rtx expand_builtin_va_copy (tree);
 118 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
 119 static rtx expand_builtin_strcmp (tree, rtx);
 120 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
 121 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 122 static rtx expand_builtin_memcpy (tree, rtx);
 123 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
 124 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
 125                                         enum machine_mode, int);
 126 static rtx expand_builtin_strcpy (tree, rtx);
 127 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
 128 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
 129 static rtx expand_builtin_strncpy (tree, rtx);
 130 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
 131 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
 132 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
 133 static rtx expand_builtin_bzero (tree);
 134 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
 135 static rtx expand_builtin_alloca (tree, rtx, bool);
 136 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
 137 static rtx expand_builtin_frame_address (tree, tree);
 138 static tree stabilize_va_list_loc (location_t, tree, int);
 139 static rtx expand_builtin_expect (tree, rtx);
 140 static tree fold_builtin_constant_p (tree);
 141 static tree fold_builtin_expect (location_t, tree, tree);
 142 static tree fold_builtin_classify_type (tree);
 143 static tree fold_builtin_strlen (location_t, tree, tree);
 144 static tree fold_builtin_inf (location_t, tree, int);
 145 static tree fold_builtin_nan (tree, tree, int);
 146 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
 147 static bool validate_arg (const_tree, enum tree_code code);
 148 static bool integer_valued_real_p (tree);
 149 static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
 150 static bool readonly_data_expr (tree);
 151 static rtx expand_builtin_fabs (tree, rtx, rtx);
 152 static rtx expand_builtin_signbit (tree, rtx);
 153 static tree fold_builtin_sqrt (location_t, tree, tree);
 154 static tree fold_builtin_cbrt (location_t, tree, tree);
 155 static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
 156 static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
 157 static tree fold_builtin_cos (location_t, tree, tree, tree);
 158 static tree fold_builtin_cosh (location_t, tree, tree, tree);
 159 static tree fold_builtin_tan (tree, tree);
 160 static tree fold_builtin_trunc (location_t, tree, tree);
 161 static tree fold_builtin_floor (location_t, tree, tree);
 162 static tree fold_builtin_ceil (location_t, tree, tree);
 163 static tree fold_builtin_round (location_t, tree, tree);
 164 static tree fold_builtin_int_roundingfn (location_t, tree, tree);
 165 static tree fold_builtin_bitop (tree, tree);
 166 static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
 167 static tree fold_builtin_strchr (location_t, tree, tree, tree);
 168 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
 169 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
 170 static tree fold_builtin_strcmp (location_t, tree, tree);
 171 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
 172 static tree fold_builtin_signbit (location_t, tree, tree);
 173 static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
 174 static tree fold_builtin_isascii (location_t, tree);
 175 static tree fold_builtin_toascii (location_t, tree);
 176 static tree fold_builtin_isdigit (location_t, tree);
 177 static tree fold_builtin_fabs (location_t, tree, tree);
 178 static tree fold_builtin_abs (location_t, tree, tree);
 179 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
 180                                         enum tree_code);
 181 static tree fold_builtin_n (location_t, tree, tree *, int, bool);
 182 static tree fold_builtin_0 (location_t, tree, bool);
 183 static tree fold_builtin_1 (location_t, tree, tree, bool);
 184 static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
 185 static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
 186 static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
 187 static tree fold_builtin_varargs (location_t, tree, tree, bool);
 188
 189 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
 190 static tree fold_builtin_strstr (location_t, tree, tree, tree);
 191 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
 192 static tree fold_builtin_strcat (location_t, tree, tree);
 193 static tree fold_builtin_strncat (location_t, tree, tree, tree);
 194 static tree fold_builtin_strspn (location_t, tree, tree);
 195 static tree fold_builtin_strcspn (location_t, tree, tree);
 196 static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
 197
 198 static rtx expand_builtin_object_size (tree);
 199 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
 200                                       enum built_in_function);
 201 static void maybe_emit_chk_warning (tree, enum built_in_function);
 202 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 203 static void maybe_emit_free_warning (tree);
 204 static tree fold_builtin_object_size (tree, tree);
 205 static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
 206 static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
 207 static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
 208 static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
 209 static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
 210                                   enum built_in_function);
 211 static bool init_target_chars (void);
 212
 213 static unsigned HOST_WIDE_INT target_newline;
 214 static unsigned HOST_WIDE_INT target_percent;
 215 static unsigned HOST_WIDE_INT target_c;
 216 static unsigned HOST_WIDE_INT target_s;
 217 static char target_percent_c[3];
 218 static char target_percent_s[3];
 219 static char target_percent_s_newline[4];
 220 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
 221                           const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
 222 static tree do_mpfr_arg2 (tree, tree, tree,
 223                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 224 static tree do_mpfr_arg3 (tree, tree, tree, tree,
 225                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 226 static tree do_mpfr_sincos (tree, tree, tree);
 227 static tree do_mpfr_bessel_n (tree, tree, tree,
 228                               int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
 229                               const REAL_VALUE_TYPE *, bool);
 230 static tree do_mpfr_remquo (tree, tree, tree);
 231 static tree do_mpfr_lgamma_r (tree, tree, tree);
 232
 233 /* Return true if NAME starts with __builtin_ or __sync_.  */
 234
 235 bool
 236 is_builtin_name (const char *name)
 237 {
 238   if (strncmp (name, "__builtin_", 10) == 0)
 239     return true;
 240   if (strncmp (name, "__sync_", 7) == 0)
 241     return true;
 242   return false;
 243 }
 244
 245
 246 /* Return true if DECL is a function symbol representing a built-in.  */
 247
 248 bool
 249 is_builtin_fn (tree decl)
 250 {
 251   return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
 252 }
 253
 254
 255 /* Return true if NODE should be considered for inline expansion regardless
 256    of the optimization level.  This means whenever a function is invoked with
 257    its "internal" name, which normally contains the prefix "__builtin".  */
 258
 259 static bool
 260 called_as_built_in (tree node)
 261 {
 262   /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
 263      we want the name used to call the function, not the name it
 264      will have. */
 265   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 266   return is_builtin_name (name);
 267 }
 268
 269 /* Return the alignment in bits of EXP, an object.
 270    Don't return more than MAX_ALIGN no matter what.  */
 271
 272 unsigned int
 273 get_object_alignment (tree exp, unsigned int max_align)
 274 {
 275   HOST_WIDE_INT bitsize, bitpos;
 276   tree offset;
 277   enum machine_mode mode;
 278   int unsignedp, volatilep;
 279   unsigned int align, inner;
 280
 281   /* Get the innermost object and the constant (bitpos) and possibly
 282      variable (offset) offset of the access.  */
 283   exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
 284                              &mode, &unsignedp, &volatilep, true);
 285
 286   /* Extract alignment information from the innermost object and
 287      possibly adjust bitpos and offset.  */
 288   if (TREE_CODE (exp) == CONST_DECL)
 289     exp = DECL_INITIAL (exp);
 290   if (DECL_P (exp)
 291       && TREE_CODE (exp) != LABEL_DECL)
 292     align = DECL_ALIGN (exp);
 293   else if (CONSTANT_CLASS_P (exp))
 294     {
 295       align = TYPE_ALIGN (TREE_TYPE (exp));
 296 #ifdef CONSTANT_ALIGNMENT
 297       align = (unsigned)CONSTANT_ALIGNMENT (exp, align);
 298 #endif
 299     }
 300   else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
 301     align = TYPE_ALIGN (TREE_TYPE (exp));
 302   else if (TREE_CODE (exp) == INDIRECT_REF)
 303     align = TYPE_ALIGN (TREE_TYPE (exp));
 304   else if (TREE_CODE (exp) == MISALIGNED_INDIRECT_REF)
 305     {
 306       tree op1 = TREE_OPERAND (exp, 1);
 307       align = integer_zerop (op1) ? BITS_PER_UNIT : TREE_INT_CST_LOW (op1);
 308     }
 309   else if (TREE_CODE (exp) == MEM_REF)
 310     {
 311       tree addr = TREE_OPERAND (exp, 0);
 312       struct ptr_info_def *pi;
 313       if (TREE_CODE (addr) == BIT_AND_EXPR
 314           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 315         {
 316           align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 317                     & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 318           align *= BITS_PER_UNIT;
 319           addr = TREE_OPERAND (addr, 0);
 320         }
 321       else
 322         align = BITS_PER_UNIT;
 323       if (TREE_CODE (addr) == SSA_NAME
 324           && (pi = SSA_NAME_PTR_INFO (addr)))
 325         {
 326           bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
 327           align = MAX (pi->align * BITS_PER_UNIT, align);
 328         }
 329       else if (TREE_CODE (addr) == ADDR_EXPR)
 330         align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
 331                                                   max_align));
 332       bitpos += mem_ref_offset (exp).low * BITS_PER_UNIT;
 333     }
 334   else if (TREE_CODE (exp) == TARGET_MEM_REF
 335            && TMR_BASE (exp)
 336            && POINTER_TYPE_P (TREE_TYPE (TMR_BASE (exp))))
 337     {
 338       struct ptr_info_def *pi;
 339       tree addr = TMR_BASE (exp);
 340       if (TREE_CODE (addr) == BIT_AND_EXPR
 341           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 342         {
 343           align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 344                    & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 345           align *= BITS_PER_UNIT;
 346           addr = TREE_OPERAND (addr, 0);
 347         }
 348       else
 349         align = BITS_PER_UNIT;
 350       if (TREE_CODE (addr) == SSA_NAME
 351           && (pi = SSA_NAME_PTR_INFO (addr)))
 352         {
 353           bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
 354           align = MAX (pi->align * BITS_PER_UNIT, align);
 355         }
 356       else if (TREE_CODE (addr) == ADDR_EXPR)
 357         align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
 358                                                   max_align));
 359       if (TMR_OFFSET (exp))
 360         bitpos += TREE_INT_CST_LOW (TMR_OFFSET (exp)) * BITS_PER_UNIT;
 361       if (TMR_INDEX (exp) && TMR_STEP (exp))
 362         {
 363           unsigned HOST_WIDE_INT step = TREE_INT_CST_LOW (TMR_STEP (exp));
 364           align = MIN (align, (step & -step) * BITS_PER_UNIT);
 365         }
 366       else if (TMR_INDEX (exp))
 367         align = BITS_PER_UNIT;
 368     }
 369   else if (TREE_CODE (exp) == TARGET_MEM_REF
 370            && TMR_SYMBOL (exp))
 371     {
 372       align = get_object_alignment (TMR_SYMBOL (exp), max_align);
 373       if (TMR_OFFSET (exp))
 374         bitpos += TREE_INT_CST_LOW (TMR_OFFSET (exp)) * BITS_PER_UNIT;
 375       if (TMR_INDEX (exp) && TMR_STEP (exp))
 376         {
 377           unsigned HOST_WIDE_INT step = TREE_INT_CST_LOW (TMR_STEP (exp));
 378           align = MIN (align, (step & -step) * BITS_PER_UNIT);
 379         }
 380       else if (TMR_INDEX (exp))
 381         align = BITS_PER_UNIT;
 382     }
 383   else
 384     align = BITS_PER_UNIT;
 385
 386   /* If there is a non-constant offset part extract the maximum
 387      alignment that can prevail.  */
 388   inner = max_align;
 389   while (offset)
 390     {
 391       tree next_offset;
 392
 393       if (TREE_CODE (offset) == PLUS_EXPR)
 394         {
 395           next_offset = TREE_OPERAND (offset, 0);
 396           offset = TREE_OPERAND (offset, 1);
 397         }
 398       else
 399         next_offset = NULL;
 400       if (host_integerp (offset, 1))
 401         {
 402           /* Any overflow in calculating offset_bits won't change
 403              the alignment.  */
 404           unsigned offset_bits
 405             = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
 406
 407           if (offset_bits)
 408             inner = MIN (inner, (offset_bits & -offset_bits));
 409         }
 410       else if (TREE_CODE (offset) == MULT_EXPR
 411                && host_integerp (TREE_OPERAND (offset, 1), 1))
 412         {
 413           /* Any overflow in calculating offset_factor won't change
 414              the alignment.  */
 415           unsigned offset_factor
 416             = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
 417                * BITS_PER_UNIT);
 418
 419           if (offset_factor)
 420             inner = MIN (inner, (offset_factor & -offset_factor));
 421         }
 422       else
 423         {
 424           inner = MIN (inner, BITS_PER_UNIT);
 425           break;
 426         }
 427       offset = next_offset;
 428     }
 429
 430   /* Alignment is innermost object alignment adjusted by the constant
 431      and non-constant offset parts.  */
 432   align = MIN (align, inner);
 433   bitpos = bitpos & (align - 1);
 434
 435   /* align and bitpos now specify known low bits of the pointer.
 436      ptr & (align - 1) == bitpos.  */
 437
 438   if (bitpos != 0)
 439     align = (bitpos & -bitpos);
 440
 441   return MIN (align, max_align);
 442 }
 443
 444 /* Returns true iff we can trust that alignment information has been
 445    calculated properly.  */
 446
 447 bool
 448 can_trust_pointer_alignment (void)
 449 {
 450   /* We rely on TER to compute accurate alignment information.  */
 451   return (optimize && flag_tree_ter);
 452 }
 453
 454 /* Return the alignment in bits of EXP, a pointer valued expression.
 455    But don't return more than MAX_ALIGN no matter what.
 456    The alignment returned is, by default, the alignment of the thing that
 457    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 458
 459    Otherwise, look at the expression to see if we can do better, i.e., if the
 460    expression is actually pointing at an object whose alignment is tighter.  */
 461
 462 unsigned int
 463 get_pointer_alignment (tree exp, unsigned int max_align)
 464 {
 465   STRIP_NOPS (exp);
 466
 467   if (TREE_CODE (exp) == ADDR_EXPR)
 468     return get_object_alignment (TREE_OPERAND (exp, 0), max_align);
 469   else if (TREE_CODE (exp) == SSA_NAME
 470            && POINTER_TYPE_P (TREE_TYPE (exp)))
 471     {
 472       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);
 473       unsigned align;
 474       if (!pi)
 475         return BITS_PER_UNIT;
 476       if (pi->misalign != 0)
 477         align = (pi->misalign & -pi->misalign);
 478       else
 479         align = pi->align;
 480       return MIN (max_align, align * BITS_PER_UNIT);
 481     }
 482
 483   return POINTER_TYPE_P (TREE_TYPE (exp)) ? BITS_PER_UNIT : 0;
 484 }
 485
 486 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 487    way, because it could contain a zero byte in the middle.
 488    TREE_STRING_LENGTH is the size of the character array, not the string.
 489
 490    ONLY_VALUE should be nonzero if the result is not going to be emitted
 491    into the instruction stream and zero if it is going to be expanded.
 492    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 493    is returned, otherwise NULL, since
 494    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
 495    evaluate the side-effects.
 496
 497    The value returned is of type `ssizetype'.
 498
 499    Unfortunately, string_constant can't access the values of const char
 500    arrays with initializers, so neither can we do so here.  */
 501
 502 tree
 503 c_strlen (tree src, int only_value)
 504 {
 505   tree offset_node;
 506   HOST_WIDE_INT offset;
 507   int max;
 508   const char *ptr;
 509   location_t loc;
 510
 511   STRIP_NOPS (src);
 512   if (TREE_CODE (src) == COND_EXPR
 513       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 514     {
 515       tree len1, len2;
 516
 517       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
 518       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
 519       if (tree_int_cst_equal (len1, len2))
 520         return len1;
 521     }
 522
 523   if (TREE_CODE (src) == COMPOUND_EXPR
 524       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 525     return c_strlen (TREE_OPERAND (src, 1), only_value);
 526
 527   if (EXPR_HAS_LOCATION (src))
 528     loc = EXPR_LOCATION (src);
 529   else
 530     loc = input_location;
 531
 532   src = string_constant (src, &offset_node);
 533   if (src == 0)
 534     return NULL_TREE;
 535
 536   max = TREE_STRING_LENGTH (src) - 1;
 537   ptr = TREE_STRING_POINTER (src);
 538
 539   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 540     {
 541       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 542          compute the offset to the following null if we don't know where to
 543          start searching for it.  */
 544       int i;
 545
 546       for (i = 0; i < max; i++)
 547         if (ptr[i] == 0)
 548           return NULL_TREE;
 549
 550       /* We don't know the starting offset, but we do know that the string
 551          has no internal zero bytes.  We can assume that the offset falls
 552          within the bounds of the string; otherwise, the programmer deserves
 553          what he gets.  Subtract the offset from the length of the string,
 554          and return that.  This would perhaps not be valid if we were dealing
 555          with named arrays in addition to literal string constants.  */
 556
 557       return size_diffop_loc (loc, size_int (max), offset_node);
 558     }
 559
 560   /* We have a known offset into the string.  Start searching there for
 561      a null character if we can represent it as a single HOST_WIDE_INT.  */
 562   if (offset_node == 0)
 563     offset = 0;
 564   else if (! host_integerp (offset_node, 0))
 565     offset = -1;
 566   else
 567     offset = tree_low_cst (offset_node, 0);
 568
 569   /* If the offset is known to be out of bounds, warn, and call strlen at
 570      runtime.  */
 571   if (offset < 0 || offset > max)
 572     {
 573      /* Suppress multiple warnings for propagated constant strings.  */
 574       if (! TREE_NO_WARNING (src))
 575         {
 576           warning_at (loc, 0, "offset outside bounds of constant string");
 577           TREE_NO_WARNING (src) = 1;
 578         }
 579       return NULL_TREE;
 580     }
 581
 582   /* Use strlen to search for the first zero byte.  Since any strings
 583      constructed with build_string will have nulls appended, we win even
 584      if we get handed something like (char[4])"abcd".
 585
 586      Since OFFSET is our starting index into the string, no further
 587      calculation is needed.  */
 588   return ssize_int (strlen (ptr + offset));
 589 }
 590
 591 /* Return a char pointer for a C string if it is a string constant
 592    or sum of string constant and integer constant.  */
 593
 594 static const char *
 595 c_getstr (tree src)
 596 {
 597   tree offset_node;
 598
 599   src = string_constant (src, &offset_node);
 600   if (src == 0)
 601     return 0;
 602
 603   if (offset_node == 0)
 604     return TREE_STRING_POINTER (src);
 605   else if (!host_integerp (offset_node, 1)
 606            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
 607     return 0;
 608
 609   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
 610 }
 611
 612 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
 613    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 614
 615 static rtx
 616 c_readstr (const char *str, enum machine_mode mode)
 617 {
 618   HOST_WIDE_INT c[2];
 619   HOST_WIDE_INT ch;
 620   unsigned int i, j;
 621
 622   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
 623
 624   c[0] = 0;
 625   c[1] = 0;
 626   ch = 1;
 627   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 628     {
 629       j = i;
 630       if (WORDS_BIG_ENDIAN)
 631         j = GET_MODE_SIZE (mode) - i - 1;
 632       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 633           && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
 634         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 635       j *= BITS_PER_UNIT;
 636       gcc_assert (j < 2 * HOST_BITS_PER_WIDE_INT);
 637
 638       if (ch)
 639         ch = (unsigned char) str[i];
 640       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 641     }
 642   return immed_double_const (c[0], c[1], mode);
 643 }
 644
 645 /* Cast a target constant CST to target CHAR and if that value fits into
 646    host char type, return zero and put that value into variable pointed to by
 647    P.  */
 648
 649 static int
 650 target_char_cast (tree cst, char *p)
 651 {
 652   unsigned HOST_WIDE_INT val, hostval;
 653
 654   if (!host_integerp (cst, 1)
 655       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 656     return 1;
 657
 658   val = tree_low_cst (cst, 1);
 659   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 660     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 661
 662   hostval = val;
 663   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 664     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 665
 666   if (val != hostval)
 667     return 1;
 668
 669   *p = hostval;
 670   return 0;
 671 }
 672
 673 /* Similar to save_expr, but assumes that arbitrary code is not executed
 674    in between the multiple evaluations.  In particular, we assume that a
 675    non-addressable local variable will not be modified.  */
 676
 677 static tree
 678 builtin_save_expr (tree exp)
 679 {
 680   if (TREE_ADDRESSABLE (exp) == 0
 681       && (TREE_CODE (exp) == PARM_DECL
 682           || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
 683     return exp;
 684
 685   return save_expr (exp);
 686 }
 687
 688 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 689    times to get the address of either a higher stack frame, or a return
 690    address located within it (depending on FNDECL_CODE).  */
 691
 692 static rtx
 693 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
 694 {
 695   int i;
 696
 697 #ifdef INITIAL_FRAME_ADDRESS_RTX
 698   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
 699 #else
 700   rtx tem;
 701
 702   /* For a zero count with __builtin_return_address, we don't care what
 703      frame address we return, because target-specific definitions will
 704      override us.  Therefore frame pointer elimination is OK, and using
 705      the soft frame pointer is OK.
 706
 707      For a nonzero count, or a zero count with __builtin_frame_address,
 708      we require a stable offset from the current frame pointer to the
 709      previous one, so we must use the hard frame pointer, and
 710      we must disable frame pointer elimination.  */
 711   if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
 712     tem = frame_pointer_rtx;
 713   else
 714     {
 715       tem = hard_frame_pointer_rtx;
 716
 717       /* Tell reload not to eliminate the frame pointer.  */
 718       crtl->accesses_prior_frames = 1;
 719     }
 720 #endif
 721
 722   /* Some machines need special handling before we can access
 723      arbitrary frames.  For example, on the SPARC, we must first flush
 724      all register windows to the stack.  */
 725 #ifdef SETUP_FRAME_ADDRESSES
 726   if (count > 0)
 727     SETUP_FRAME_ADDRESSES ();
 728 #endif
 729
 730   /* On the SPARC, the return address is not in the frame, it is in a
 731      register.  There is no way to access it off of the current frame
 732      pointer, but it can be accessed off the previous frame pointer by
 733      reading the value from the register window save area.  */
 734 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
 735   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
 736     count--;
 737 #endif
 738
 739   /* Scan back COUNT frames to the specified frame.  */
 740   for (i = 0; i < count; i++)
 741     {
 742       /* Assume the dynamic chain pointer is in the word that the
 743          frame address points to, unless otherwise specified.  */
 744 #ifdef DYNAMIC_CHAIN_ADDRESS
 745       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 746 #endif
 747       tem = memory_address (Pmode, tem);
 748       tem = gen_frame_mem (Pmode, tem);
 749       tem = copy_to_reg (tem);
 750     }
 751
 752   /* For __builtin_frame_address, return what we've got.  But, on
 753      the SPARC for example, we may have to add a bias.  */
 754   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 755 #ifdef FRAME_ADDR_RTX
 756     return FRAME_ADDR_RTX (tem);
 757 #else
 758     return tem;
 759 #endif
 760
 761   /* For __builtin_return_address, get the return address from that frame.  */
 762 #ifdef RETURN_ADDR_RTX
 763   tem = RETURN_ADDR_RTX (count, tem);
 764 #else
 765   tem = memory_address (Pmode,
 766                         plus_constant (tem, GET_MODE_SIZE (Pmode)));
 767   tem = gen_frame_mem (Pmode, tem);
 768 #endif
 769   return tem;
 770 }
 771
 772 /* Alias set used for setjmp buffer.  */
 773 static alias_set_type setjmp_alias_set = -1;
 774
 775 /* Construct the leading half of a __builtin_setjmp call.  Control will
 776    return to RECEIVER_LABEL.  This is also called directly by the SJLJ
 777    exception handling code.  */
 778
 779 void
 780 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 781 {
 782   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 783   rtx stack_save;
 784   rtx mem;
 785
 786   if (setjmp_alias_set == -1)
 787     setjmp_alias_set = new_alias_set ();
 788
 789   buf_addr = convert_memory_address (Pmode, buf_addr);
 790
 791   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 792
 793   /* We store the frame pointer and the address of receiver_label in
 794      the buffer and use the rest of it for the stack save area, which
 795      is machine-dependent.  */
 796
 797   mem = gen_rtx_MEM (Pmode, buf_addr);
 798   set_mem_alias_set (mem, setjmp_alias_set);
 799   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
 800
 801   mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
 802   set_mem_alias_set (mem, setjmp_alias_set);
 803
 804   emit_move_insn (validize_mem (mem),
 805                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 806
 807   stack_save = gen_rtx_MEM (sa_mode,
 808                             plus_constant (buf_addr,
 809                                            2 * GET_MODE_SIZE (Pmode)));
 810   set_mem_alias_set (stack_save, setjmp_alias_set);
 811   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
 812
 813   /* If there is further processing to do, do it.  */
 814 #ifdef HAVE_builtin_setjmp_setup
 815   if (HAVE_builtin_setjmp_setup)
 816     emit_insn (gen_builtin_setjmp_setup (buf_addr));
 817 #endif
 818
 819   /* Tell optimize_save_area_alloca that extra work is going to
 820      need to go on during alloca.  */
 821   cfun->calls_setjmp = 1;
 822
 823   /* We have a nonlocal label.   */
 824   cfun->has_nonlocal_label = 1;
 825 }
 826
 827 /* Construct the trailing part of a __builtin_setjmp call.  This is
 828    also called directly by the SJLJ exception handling code.  */
 829
 830 void
 831 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
 832 {
 833   rtx chain;
 834
 835   /* Clobber the FP when we get here, so we have to make sure it's
 836      marked as used by this function.  */
 837   emit_use (hard_frame_pointer_rtx);
 838
 839   /* Mark the static chain as clobbered here so life information
 840      doesn't get messed up for it.  */
 841   chain = targetm.calls.static_chain (current_function_decl, true);
 842   if (chain && REG_P (chain))
 843     emit_clobber (chain);
 844
 845   /* Now put in the code to restore the frame pointer, and argument
 846      pointer, if needed.  */
 847 #ifdef HAVE_nonlocal_goto
 848   if (! HAVE_nonlocal_goto)
 849 #endif
 850     {
 851       emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 852       /* This might change the hard frame pointer in ways that aren't
 853          apparent to early optimization passes, so force a clobber.  */
 854       emit_clobber (hard_frame_pointer_rtx);
 855     }
 856
 857 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 858   if (fixed_regs[ARG_POINTER_REGNUM])
 859     {
 860 #ifdef ELIMINABLE_REGS
 861       size_t i;
 862       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 863
 864       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 865         if (elim_regs[i].from == ARG_POINTER_REGNUM
 866             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 867           break;
 868
 869       if (i == ARRAY_SIZE (elim_regs))
 870 #endif
 871         {
 872           /* Now restore our arg pointer from the address at which it
 873              was saved in our stack frame.  */
 874           emit_move_insn (crtl->args.internal_arg_pointer,
 875                           copy_to_reg (get_arg_pointer_save_area ()));
 876         }
 877     }
 878 #endif
 879
 880 #ifdef HAVE_builtin_setjmp_receiver
 881   if (HAVE_builtin_setjmp_receiver)
 882     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
 883   else
 884 #endif
 885 #ifdef HAVE_nonlocal_goto_receiver
 886     if (HAVE_nonlocal_goto_receiver)
 887       emit_insn (gen_nonlocal_goto_receiver ());
 888     else
 889 #endif
 890       { /* Nothing */ }
 891
 892   /* We must not allow the code we just generated to be reordered by
 893      scheduling.  Specifically, the update of the frame pointer must
 894      happen immediately, not later.  */
 895   emit_insn (gen_blockage ());
 896 }
 897
 898 /* __builtin_longjmp is passed a pointer to an array of five words (not
 899    all will be used on all machines).  It operates similarly to the C
 900    library function of the same name, but is more efficient.  Much of
 901    the code below is copied from the handling of non-local gotos.  */
 902
 903 static void
 904 expand_builtin_longjmp (rtx buf_addr, rtx value)
 905 {
 906   rtx fp, lab, stack, insn, last;
 907   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 908
 909   /* DRAP is needed for stack realign if longjmp is expanded to current
 910      function  */
 911   if (SUPPORTS_STACK_ALIGNMENT)
 912     crtl->need_drap = true;
 913
 914   if (setjmp_alias_set == -1)
 915     setjmp_alias_set = new_alias_set ();
 916
 917   buf_addr = convert_memory_address (Pmode, buf_addr);
 918
 919   buf_addr = force_reg (Pmode, buf_addr);
 920
 921   /* We require that the user must pass a second argument of 1, because
 922      that is what builtin_setjmp will return.  */
 923   gcc_assert (value == const1_rtx);
 924
 925   last = get_last_insn ();
 926 #ifdef HAVE_builtin_longjmp
 927   if (HAVE_builtin_longjmp)
 928     emit_insn (gen_builtin_longjmp (buf_addr));
 929   else
 930 #endif
 931     {
 932       fp = gen_rtx_MEM (Pmode, buf_addr);
 933       lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
 934                                                GET_MODE_SIZE (Pmode)));
 935
 936       stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
 937                                                    2 * GET_MODE_SIZE (Pmode)));
 938       set_mem_alias_set (fp, setjmp_alias_set);
 939       set_mem_alias_set (lab, setjmp_alias_set);
 940       set_mem_alias_set (stack, setjmp_alias_set);
 941
 942       /* Pick up FP, label, and SP from the block and jump.  This code is
 943          from expand_goto in stmt.c; see there for detailed comments.  */
 944 #ifdef HAVE_nonlocal_goto
 945       if (HAVE_nonlocal_goto)
 946         /* We have to pass a value to the nonlocal_goto pattern that will
 947            get copied into the static_chain pointer, but it does not matter
 948            what that value is, because builtin_setjmp does not use it.  */
 949         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
 950       else
 951 #endif
 952         {
 953           lab = copy_to_reg (lab);
 954
 955           emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 956           emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 957
 958           emit_move_insn (hard_frame_pointer_rtx, fp);
 959           emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
 960
 961           emit_use (hard_frame_pointer_rtx);
 962           emit_use (stack_pointer_rtx);
 963           emit_indirect_jump (lab);
 964         }
 965     }
 966
 967   /* Search backwards and mark the jump insn as a non-local goto.
 968      Note that this precludes the use of __builtin_longjmp to a
 969      __builtin_setjmp target in the same function.  However, we've
 970      already cautioned the user that these functions are for
 971      internal exception handling use only.  */
 972   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 973     {
 974       gcc_assert (insn != last);
 975
 976       if (JUMP_P (insn))
 977         {
 978           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
 979           break;
 980         }
 981       else if (CALL_P (insn))
 982         break;
 983     }
 984 }
 985
 986 /* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
 987    and the address of the save area.  */
 988
 989 static rtx
 990 expand_builtin_nonlocal_goto (tree exp)
 991 {
 992   tree t_label, t_save_area;
 993   rtx r_label, r_save_area, r_fp, r_sp, insn;
 994
 995   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
 996     return NULL_RTX;
 997
 998   t_label = CALL_EXPR_ARG (exp, 0);
 999   t_save_area = CALL_EXPR_ARG (exp, 1);
1000
1001   r_label = expand_normal (t_label);
1002   r_label = convert_memory_address (Pmode, r_label);
1003   r_save_area = expand_normal (t_save_area);
1004   r_save_area = convert_memory_address (Pmode, r_save_area);
1005   /* Copy the address of the save location to a register just in case it was based
1006     on the frame pointer.   */
1007   r_save_area = copy_to_reg (r_save_area);
1008   r_fp = gen_rtx_MEM (Pmode, r_save_area);
1009   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
1010                       plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
1011
1012   crtl->has_nonlocal_goto = 1;
1013
1014 #ifdef HAVE_nonlocal_goto
1015   /* ??? We no longer need to pass the static chain value, afaik.  */
1016   if (HAVE_nonlocal_goto)
1017     emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
1018   else
1019 #endif
1020     {
1021       r_label = copy_to_reg (r_label);
1022
1023       emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1024       emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1025
1026       /* Restore frame pointer for containing function.
1027          This sets the actual hard register used for the frame pointer
1028          to the location of the function's incoming static chain info.
1029          The non-local goto handler will then adjust it to contain the
1030          proper value and reload the argument pointer, if needed.  */
1031       emit_move_insn (hard_frame_pointer_rtx, r_fp);
1032       emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
1033
1034       /* USE of hard_frame_pointer_rtx added for consistency;
1035          not clear if really needed.  */
1036       emit_use (hard_frame_pointer_rtx);
1037       emit_use (stack_pointer_rtx);
1038
1039       /* If the architecture is using a GP register, we must
1040          conservatively assume that the target function makes use of it.
1041          The prologue of functions with nonlocal gotos must therefore
1042          initialize the GP register to the appropriate value, and we
1043          must then make sure that this value is live at the point
1044          of the jump.  (Note that this doesn't necessarily apply
1045          to targets with a nonlocal_goto pattern; they are free
1046          to implement it in their own way.  Note also that this is
1047          a no-op if the GP register is a global invariant.)  */
1048       if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
1049           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
1050         emit_use (pic_offset_table_rtx);
1051
1052       emit_indirect_jump (r_label);
1053     }
1054
1055   /* Search backwards to the jump insn and mark it as a
1056      non-local goto.  */
1057   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1058     {
1059       if (JUMP_P (insn))
1060         {
1061           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1062           break;
1063         }
1064       else if (CALL_P (insn))
1065         break;
1066     }
1067
1068   return const0_rtx;
1069 }
1070
1071 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1072    (not all will be used on all machines) that was passed to __builtin_setjmp.
1073    It updates the stack pointer in that block to correspond to the current
1074    stack pointer.  */
1075
1076 static void
1077 expand_builtin_update_setjmp_buf (rtx buf_addr)
1078 {
1079   enum machine_mode sa_mode = Pmode;
1080   rtx stack_save;
1081
1082
1083 #ifdef HAVE_save_stack_nonlocal
1084   if (HAVE_save_stack_nonlocal)
1085     sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
1086 #endif
1087 #ifdef STACK_SAVEAREA_MODE
1088   sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1089 #endif
1090
1091   stack_save
1092     = gen_rtx_MEM (sa_mode,
1093                    memory_address
1094                    (sa_mode,
1095                     plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1096
1097 #ifdef HAVE_setjmp
1098   if (HAVE_setjmp)
1099     emit_insn (gen_setjmp ());
1100 #endif
1101
1102   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
1103 }
1104
1105 /* Expand a call to __builtin_prefetch.  For a target that does not support
1106    data prefetch, evaluate the memory address argument in case it has side
1107    effects.  */
1108
1109 static void
1110 expand_builtin_prefetch (tree exp)
1111 {
1112   tree arg0, arg1, arg2;
1113   int nargs;
1114   rtx op0, op1, op2;
1115
1116   if (!validate_arglist (exp, POINTER_TYPE, 0))
1117     return;
1118
1119   arg0 = CALL_EXPR_ARG (exp, 0);
1120
1121   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1122      zero (read) and argument 2 (locality) defaults to 3 (high degree of
1123      locality).  */
1124   nargs = call_expr_nargs (exp);
1125   if (nargs > 1)
1126     arg1 = CALL_EXPR_ARG (exp, 1);
1127   else
1128     arg1 = integer_zero_node;
1129   if (nargs > 2)
1130     arg2 = CALL_EXPR_ARG (exp, 2);
1131   else
1132     arg2 = integer_three_node;
1133
1134   /* Argument 0 is an address.  */
1135   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1136
1137   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
1138   if (TREE_CODE (arg1) != INTEGER_CST)
1139     {
1140       error ("second argument to %<__builtin_prefetch%> must be a constant");
1141       arg1 = integer_zero_node;
1142     }
1143   op1 = expand_normal (arg1);
1144   /* Argument 1 must be either zero or one.  */
1145   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1146     {
1147       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1148                " using zero");
1149       op1 = const0_rtx;
1150     }
1151
1152   /* Argument 2 (locality) must be a compile-time constant int.  */
1153   if (TREE_CODE (arg2) != INTEGER_CST)
1154     {
1155       error ("third argument to %<__builtin_prefetch%> must be a constant");
1156       arg2 = integer_zero_node;
1157     }
1158   op2 = expand_normal (arg2);
1159   /* Argument 2 must be 0, 1, 2, or 3.  */
1160   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1161     {
1162       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1163       op2 = const0_rtx;
1164     }
1165
1166 #ifdef HAVE_prefetch
1167   if (HAVE_prefetch)
1168     {
1169       if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
1170              (op0,
1171               insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1172           || (GET_MODE (op0) != Pmode))
1173         {
1174           op0 = convert_memory_address (Pmode, op0);
1175           op0 = force_reg (Pmode, op0);
1176         }
1177       emit_insn (gen_prefetch (op0, op1, op2));
1178     }
1179 #endif
1180
1181   /* Don't do anything with direct references to volatile memory, but
1182      generate code to handle other side effects.  */
1183   if (!MEM_P (op0) && side_effects_p (op0))
1184     emit_insn (op0);
1185 }
1186
1187 /* Get a MEM rtx for expression EXP which is the address of an operand
1188    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1189    the maximum length of the block of memory that might be accessed or
1190    NULL if unknown.  */
1191
1192 static rtx
1193 get_memory_rtx (tree exp, tree len)
1194 {
1195   tree orig_exp = exp;
1196   rtx addr, mem;
1197   HOST_WIDE_INT off;
1198
1199   /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1200      from its expression, for expr->a.b only <variable>.a.b is recorded.  */
1201   if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1202     exp = TREE_OPERAND (exp, 0);
1203
1204   addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1205   mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1206
1207   /* Get an expression we can use to find the attributes to assign to MEM.
1208      If it is an ADDR_EXPR, use the operand.  Otherwise, dereference it if
1209      we can.  First remove any nops.  */
1210   while (CONVERT_EXPR_P (exp)
1211          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1212     exp = TREE_OPERAND (exp, 0);
1213
1214   off = 0;
1215   if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1216       && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1217       && host_integerp (TREE_OPERAND (exp, 1), 0)
1218       && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1219     exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1220   else if (TREE_CODE (exp) == ADDR_EXPR)
1221     exp = TREE_OPERAND (exp, 0);
1222   else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1223     exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1224   else
1225     exp = NULL;
1226
1227   /* Honor attributes derived from exp, except for the alias set
1228      (as builtin stringops may alias with anything) and the size
1229      (as stringops may access multiple array elements).  */
1230   if (exp)
1231     {
1232       set_mem_attributes (mem, exp, 0);
1233
1234       if (off)
1235         mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1236
1237       /* Allow the string and memory builtins to overflow from one
1238          field into another, see http://gcc.gnu.org/PR23561.
1239          Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1240          memory accessed by the string or memory builtin will fit
1241          within the field.  */
1242       if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1243         {
1244           tree mem_expr = MEM_EXPR (mem);
1245           HOST_WIDE_INT offset = -1, length = -1;
1246           tree inner = exp;
1247
1248           while (TREE_CODE (inner) == ARRAY_REF
1249                  || CONVERT_EXPR_P (inner)
1250                  || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1251                  || TREE_CODE (inner) == SAVE_EXPR)
1252             inner = TREE_OPERAND (inner, 0);
1253
1254           gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1255
1256           if (MEM_OFFSET (mem)
1257               && CONST_INT_P (MEM_OFFSET (mem)))
1258             offset = INTVAL (MEM_OFFSET (mem));
1259
1260           if (offset >= 0 && len && host_integerp (len, 0))
1261             length = tree_low_cst (len, 0);
1262
1263           while (TREE_CODE (inner) == COMPONENT_REF)
1264             {
1265               tree field = TREE_OPERAND (inner, 1);
1266               gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1267               gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1268
1269               /* Bitfields are generally not byte-addressable.  */
1270               gcc_assert (!DECL_BIT_FIELD (field)
1271                           || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1272                                % BITS_PER_UNIT) == 0
1273                               && host_integerp (DECL_SIZE (field), 0)
1274                               && (TREE_INT_CST_LOW (DECL_SIZE (field))
1275                                   % BITS_PER_UNIT) == 0));
1276
1277               /* If we can prove that the memory starting at XEXP (mem, 0) and
1278                  ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1279                  can keep the COMPONENT_REF in MEM_EXPR.  But be careful with
1280                  fields without DECL_SIZE_UNIT like flexible array members.  */
1281               if (length >= 0
1282                   && DECL_SIZE_UNIT (field)
1283                   && host_integerp (DECL_SIZE_UNIT (field), 0))
1284                 {
1285                   HOST_WIDE_INT size
1286                     = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1287                   if (offset <= size
1288                       && length <= size
1289                       && offset + length <= size)
1290                     break;
1291                 }
1292
1293               if (offset >= 0
1294                   && host_integerp (DECL_FIELD_OFFSET (field), 0))
1295                 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1296                           + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1297                             / BITS_PER_UNIT;
1298               else
1299                 {
1300                   offset = -1;
1301                   length = -1;
1302                 }
1303
1304               mem_expr = TREE_OPERAND (mem_expr, 0);
1305               inner = TREE_OPERAND (inner, 0);
1306             }
1307
1308           if (mem_expr == NULL)
1309             offset = -1;
1310           if (mem_expr != MEM_EXPR (mem))
1311             {
1312               set_mem_expr (mem, mem_expr);
1313               set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1314             }
1315         }
1316       set_mem_alias_set (mem, 0);
1317       set_mem_size (mem, NULL_RTX);
1318     }
1319
1320   return mem;
1321 }
1322 \f
1323 /* Built-in functions to perform an untyped call and return.  */
1324
1325 #define apply_args_mode \
1326   (this_target_builtins->x_apply_args_mode)
1327 #define apply_result_mode \
1328   (this_target_builtins->x_apply_result_mode)
1329
1330 /* Return the size required for the block returned by __builtin_apply_args,
1331    and initialize apply_args_mode.  */
1332
1333 static int
1334 apply_args_size (void)
1335 {
1336   static int size = -1;
1337   int align;
1338   unsigned int regno;
1339   enum machine_mode mode;
1340
1341   /* The values computed by this function never change.  */
1342   if (size < 0)
1343     {
1344       /* The first value is the incoming arg-pointer.  */
1345       size = GET_MODE_SIZE (Pmode);
1346
1347       /* The second value is the structure value address unless this is
1348          passed as an "invisible" first argument.  */
1349       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1350         size += GET_MODE_SIZE (Pmode);
1351
1352       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1353         if (FUNCTION_ARG_REGNO_P (regno))
1354           {
1355             mode = reg_raw_mode[regno];
1356
1357             gcc_assert (mode != VOIDmode);
1358
1359             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1360             if (size % align != 0)
1361               size = CEIL (size, align) * align;
1362             size += GET_MODE_SIZE (mode);
1363             apply_args_mode[regno] = mode;
1364           }
1365         else
1366           {
1367             apply_args_mode[regno] = VOIDmode;
1368           }
1369     }
1370   return size;
1371 }
1372
1373 /* Return the size required for the block returned by __builtin_apply,
1374    and initialize apply_result_mode.  */
1375
1376 static int
1377 apply_result_size (void)
1378 {
1379   static int size = -1;
1380   int align, regno;
1381   enum machine_mode mode;
1382
1383   /* The values computed by this function never change.  */
1384   if (size < 0)
1385     {
1386       size = 0;
1387
1388       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1389         if (targetm.calls.function_value_regno_p (regno))
1390           {
1391             mode = reg_raw_mode[regno];
1392
1393             gcc_assert (mode != VOIDmode);
1394
1395             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1396             if (size % align != 0)
1397               size = CEIL (size, align) * align;
1398             size += GET_MODE_SIZE (mode);
1399             apply_result_mode[regno] = mode;
1400           }
1401         else
1402           apply_result_mode[regno] = VOIDmode;
1403
1404       /* Allow targets that use untyped_call and untyped_return to override
1405          the size so that machine-specific information can be stored here.  */
1406 #ifdef APPLY_RESULT_SIZE
1407       size = APPLY_RESULT_SIZE;
1408 #endif
1409     }
1410   return size;
1411 }
1412
1413 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1414 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1415    the result block is used to save the values; otherwise it is used to
1416    restore the values.  */
1417
1418 static rtx
1419 result_vector (int savep, rtx result)
1420 {
1421   int regno, size, align, nelts;
1422   enum machine_mode mode;
1423   rtx reg, mem;
1424   rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1425
1426   size = nelts = 0;
1427   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1428     if ((mode = apply_result_mode[regno]) != VOIDmode)
1429       {
1430         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1431         if (size % align != 0)
1432           size = CEIL (size, align) * align;
1433         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1434         mem = adjust_address (result, mode, size);
1435         savevec[nelts++] = (savep
1436                             ? gen_rtx_SET (VOIDmode, mem, reg)
1437                             : gen_rtx_SET (VOIDmode, reg, mem));
1438         size += GET_MODE_SIZE (mode);
1439       }
1440   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1441 }
1442 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1443
1444 /* Save the state required to perform an untyped call with the same
1445    arguments as were passed to the current function.  */
1446
1447 static rtx
1448 expand_builtin_apply_args_1 (void)
1449 {
1450   rtx registers, tem;
1451   int size, align, regno;
1452   enum machine_mode mode;
1453   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1454
1455   /* Create a block where the arg-pointer, structure value address,
1456      and argument registers can be saved.  */
1457   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1458
1459   /* Walk past the arg-pointer and structure value address.  */
1460   size = GET_MODE_SIZE (Pmode);
1461   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1462     size += GET_MODE_SIZE (Pmode);
1463
1464   /* Save each register used in calling a function to the block.  */
1465   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1466     if ((mode = apply_args_mode[regno]) != VOIDmode)
1467       {
1468         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1469         if (size % align != 0)
1470           size = CEIL (size, align) * align;
1471
1472         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1473
1474         emit_move_insn (adjust_address (registers, mode, size), tem);
1475         size += GET_MODE_SIZE (mode);
1476       }
1477
1478   /* Save the arg pointer to the block.  */
1479   tem = copy_to_reg (crtl->args.internal_arg_pointer);
1480 #ifdef STACK_GROWS_DOWNWARD
1481   /* We need the pointer as the caller actually passed them to us, not
1482      as we might have pretended they were passed.  Make sure it's a valid
1483      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1484   tem
1485     = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1486                      NULL_RTX);
1487 #endif
1488   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1489
1490   size = GET_MODE_SIZE (Pmode);
1491
1492   /* Save the structure value address unless this is passed as an
1493      "invisible" first argument.  */
1494   if (struct_incoming_value)
1495     {
1496       emit_move_insn (adjust_address (registers, Pmode, size),
1497                       copy_to_reg (struct_incoming_value));
1498       size += GET_MODE_SIZE (Pmode);
1499     }
1500
1501   /* Return the address of the block.  */
1502   return copy_addr_to_reg (XEXP (registers, 0));
1503 }
1504
1505 /* __builtin_apply_args returns block of memory allocated on
1506    the stack into which is stored the arg pointer, structure
1507    value address, static chain, and all the registers that might
1508    possibly be used in performing a function call.  The code is
1509    moved to the start of the function so the incoming values are
1510    saved.  */
1511
1512 static rtx
1513 expand_builtin_apply_args (void)
1514 {
1515   /* Don't do __builtin_apply_args more than once in a function.
1516      Save the result of the first call and reuse it.  */
1517   if (apply_args_value != 0)
1518     return apply_args_value;
1519   {
1520     /* When this function is called, it means that registers must be
1521        saved on entry to this function.  So we migrate the
1522        call to the first insn of this function.  */
1523     rtx temp;
1524     rtx seq;
1525
1526     start_sequence ();
1527     temp = expand_builtin_apply_args_1 ();
1528     seq = get_insns ();
1529     end_sequence ();
1530
1531     apply_args_value = temp;
1532
1533     /* Put the insns after the NOTE that starts the function.
1534        If this is inside a start_sequence, make the outer-level insn
1535        chain current, so the code is placed at the start of the
1536        function.  If internal_arg_pointer is a non-virtual pseudo,
1537        it needs to be placed after the function that initializes
1538        that pseudo.  */
1539     push_topmost_sequence ();
1540     if (REG_P (crtl->args.internal_arg_pointer)
1541         && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1542       emit_insn_before (seq, parm_birth_insn);
1543     else
1544       emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1545     pop_topmost_sequence ();
1546     return temp;
1547   }
1548 }
1549
1550 /* Perform an untyped call and save the state required to perform an
1551    untyped return of whatever value was returned by the given function.  */
1552
1553 static rtx
1554 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1555 {
1556   int size, align, regno;
1557   enum machine_mode mode;
1558   rtx incoming_args, result, reg, dest, src, call_insn;
1559   rtx old_stack_level = 0;
1560   rtx call_fusage = 0;
1561   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1562
1563   arguments = convert_memory_address (Pmode, arguments);
1564
1565   /* Create a block where the return registers can be saved.  */
1566   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1567
1568   /* Fetch the arg pointer from the ARGUMENTS block.  */
1569   incoming_args = gen_reg_rtx (Pmode);
1570   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1571 #ifndef STACK_GROWS_DOWNWARD
1572   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1573                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1574 #endif
1575
1576   /* Push a new argument block and copy the arguments.  Do not allow
1577      the (potential) memcpy call below to interfere with our stack
1578      manipulations.  */
1579   do_pending_stack_adjust ();
1580   NO_DEFER_POP;
1581
1582   /* Save the stack with nonlocal if available.  */
1583 #ifdef HAVE_save_stack_nonlocal
1584   if (HAVE_save_stack_nonlocal)
1585     emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1586   else
1587 #endif
1588     emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1589
1590   /* Allocate a block of memory onto the stack and copy the memory
1591      arguments to the outgoing arguments address.  We can pass TRUE
1592      as the 4th argument because we just saved the stack pointer
1593      and will restore it right after the call.  */
1594   allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT, TRUE);
1595
1596   /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1597      may have already set current_function_calls_alloca to true.
1598      current_function_calls_alloca won't be set if argsize is zero,
1599      so we have to guarantee need_drap is true here.  */
1600   if (SUPPORTS_STACK_ALIGNMENT)
1601     crtl->need_drap = true;
1602
1603   dest = virtual_outgoing_args_rtx;
1604 #ifndef STACK_GROWS_DOWNWARD
1605   if (CONST_INT_P (argsize))
1606     dest = plus_constant (dest, -INTVAL (argsize));
1607   else
1608     dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1609 #endif
1610   dest = gen_rtx_MEM (BLKmode, dest);
1611   set_mem_align (dest, PARM_BOUNDARY);
1612   src = gen_rtx_MEM (BLKmode, incoming_args);
1613   set_mem_align (src, PARM_BOUNDARY);
1614   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1615
1616   /* Refer to the argument block.  */
1617   apply_args_size ();
1618   arguments = gen_rtx_MEM (BLKmode, arguments);
1619   set_mem_align (arguments, PARM_BOUNDARY);
1620
1621   /* Walk past the arg-pointer and structure value address.  */
1622   size = GET_MODE_SIZE (Pmode);
1623   if (struct_value)
1624     size += GET_MODE_SIZE (Pmode);
1625
1626   /* Restore each of the registers previously saved.  Make USE insns
1627      for each of these registers for use in making the call.  */
1628   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1629     if ((mode = apply_args_mode[regno]) != VOIDmode)
1630       {
1631         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1632         if (size % align != 0)
1633           size = CEIL (size, align) * align;
1634         reg = gen_rtx_REG (mode, regno);
1635         emit_move_insn (reg, adjust_address (arguments, mode, size));
1636         use_reg (&call_fusage, reg);
1637         size += GET_MODE_SIZE (mode);
1638       }
1639
1640   /* Restore the structure value address unless this is passed as an
1641      "invisible" first argument.  */
1642   size = GET_MODE_SIZE (Pmode);
1643   if (struct_value)
1644     {
1645       rtx value = gen_reg_rtx (Pmode);
1646       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1647       emit_move_insn (struct_value, value);
1648       if (REG_P (struct_value))
1649         use_reg (&call_fusage, struct_value);
1650       size += GET_MODE_SIZE (Pmode);
1651     }
1652
1653   /* All arguments and registers used for the call are set up by now!  */
1654   function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1655
1656   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1657      and we don't want to load it into a register as an optimization,
1658      because prepare_call_address already did it if it should be done.  */
1659   if (GET_CODE (function) != SYMBOL_REF)
1660     function = memory_address (FUNCTION_MODE, function);
1661
1662   /* Generate the actual call instruction and save the return value.  */
1663 #ifdef HAVE_untyped_call
1664   if (HAVE_untyped_call)
1665     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1666                                       result, result_vector (1, result)));
1667   else
1668 #endif
1669 #ifdef HAVE_call_value
1670   if (HAVE_call_value)
1671     {
1672       rtx valreg = 0;
1673
1674       /* Locate the unique return register.  It is not possible to
1675          express a call that sets more than one return register using
1676          call_value; use untyped_call for that.  In fact, untyped_call
1677          only needs to save the return registers in the given block.  */
1678       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1679         if ((mode = apply_result_mode[regno]) != VOIDmode)
1680           {
1681             gcc_assert (!valreg); /* HAVE_untyped_call required.  */
1682
1683             valreg = gen_rtx_REG (mode, regno);
1684           }
1685
1686       emit_call_insn (GEN_CALL_VALUE (valreg,
1687                                       gen_rtx_MEM (FUNCTION_MODE, function),
1688                                       const0_rtx, NULL_RTX, const0_rtx));
1689
1690       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1691     }
1692   else
1693 #endif
1694     gcc_unreachable ();
1695
1696   /* Find the CALL insn we just emitted, and attach the register usage
1697      information.  */
1698   call_insn = last_call_insn ();
1699   add_function_usage_to (call_insn, call_fusage);
1700
1701   /* Restore the stack.  */
1702 #ifdef HAVE_save_stack_nonlocal
1703   if (HAVE_save_stack_nonlocal)
1704     emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1705   else
1706 #endif
1707     emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1708
1709   OK_DEFER_POP;
1710
1711   /* Return the address of the result block.  */
1712   result = copy_addr_to_reg (XEXP (result, 0));
1713   return convert_memory_address (ptr_mode, result);
1714 }
1715
1716 /* Perform an untyped return.  */
1717
1718 static void
1719 expand_builtin_return (rtx result)
1720 {
1721   int size, align, regno;
1722   enum machine_mode mode;
1723   rtx reg;
1724   rtx call_fusage = 0;
1725
1726   result = convert_memory_address (Pmode, result);
1727
1728   apply_result_size ();
1729   result = gen_rtx_MEM (BLKmode, result);
1730
1731 #ifdef HAVE_untyped_return
1732   if (HAVE_untyped_return)
1733     {
1734       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1735       emit_barrier ();
1736       return;
1737     }
1738 #endif
1739
1740   /* Restore the return value and note that each value is used.  */
1741   size = 0;
1742   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1743     if ((mode = apply_result_mode[regno]) != VOIDmode)
1744       {
1745         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1746         if (size % align != 0)
1747           size = CEIL (size, align) * align;
1748         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1749         emit_move_insn (reg, adjust_address (result, mode, size));
1750
1751         push_to_sequence (call_fusage);
1752         emit_use (reg);
1753         call_fusage = get_insns ();
1754         end_sequence ();
1755         size += GET_MODE_SIZE (mode);
1756       }
1757
1758   /* Put the USE insns before the return.  */
1759   emit_insn (call_fusage);
1760
1761   /* Return whatever values was restored by jumping directly to the end
1762      of the function.  */
1763   expand_naked_return ();
1764 }
1765
1766 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1767
1768 static enum type_class
1769 type_to_class (tree type)
1770 {
1771   switch (TREE_CODE (type))
1772     {
1773     case VOID_TYPE:        return void_type_class;
1774     case INTEGER_TYPE:     return integer_type_class;
1775     case ENUMERAL_TYPE:    return enumeral_type_class;
1776     case BOOLEAN_TYPE:     return boolean_type_class;
1777     case POINTER_TYPE:     return pointer_type_class;
1778     case REFERENCE_TYPE:   return reference_type_class;
1779     case OFFSET_TYPE:      return offset_type_class;
1780     case REAL_TYPE:        return real_type_class;
1781     case COMPLEX_TYPE:     return complex_type_class;
1782     case FUNCTION_TYPE:    return function_type_class;
1783     case METHOD_TYPE:      return method_type_class;
1784     case RECORD_TYPE:      return record_type_class;
1785     case UNION_TYPE:
1786     case QUAL_UNION_TYPE:  return union_type_class;
1787     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1788                                    ? string_type_class : array_type_class);
1789     case LANG_TYPE:        return lang_type_class;
1790     default:               return no_type_class;
1791     }
1792 }
1793
1794 /* Expand a call EXP to __builtin_classify_type.  */
1795
1796 static rtx
1797 expand_builtin_classify_type (tree exp)
1798 {
1799   if (call_expr_nargs (exp))
1800     return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1801   return GEN_INT (no_type_class);
1802 }
1803
1804 /* This helper macro, meant to be used in mathfn_built_in below,
1805    determines which among a set of three builtin math functions is
1806    appropriate for a given type mode.  The `F' and `L' cases are
1807    automatically generated from the `double' case.  */
1808 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1809   case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1810   fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1811   fcodel = BUILT_IN_MATHFN##L ; break;
1812 /* Similar to above, but appends _R after any F/L suffix.  */
1813 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1814   case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1815   fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1816   fcodel = BUILT_IN_MATHFN##L_R ; break;
1817
1818 /* Return mathematic function equivalent to FN but operating directly
1819    on TYPE, if available.  If IMPLICIT is true find the function in
1820    implicit_built_in_decls[], otherwise use built_in_decls[].  If we
1821    can't do the conversion, return zero.  */
1822
1823 static tree
1824 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit)
1825 {
1826   tree const *const fn_arr
1827     = implicit ? implicit_built_in_decls : built_in_decls;
1828   enum built_in_function fcode, fcodef, fcodel;
1829
1830   switch (fn)
1831     {
1832       CASE_MATHFN (BUILT_IN_ACOS)
1833       CASE_MATHFN (BUILT_IN_ACOSH)
1834       CASE_MATHFN (BUILT_IN_ASIN)
1835       CASE_MATHFN (BUILT_IN_ASINH)
1836       CASE_MATHFN (BUILT_IN_ATAN)
1837       CASE_MATHFN (BUILT_IN_ATAN2)
1838       CASE_MATHFN (BUILT_IN_ATANH)
1839       CASE_MATHFN (BUILT_IN_CBRT)
1840       CASE_MATHFN (BUILT_IN_CEIL)
1841       CASE_MATHFN (BUILT_IN_CEXPI)
1842       CASE_MATHFN (BUILT_IN_COPYSIGN)
1843       CASE_MATHFN (BUILT_IN_COS)
1844       CASE_MATHFN (BUILT_IN_COSH)
1845       CASE_MATHFN (BUILT_IN_DREM)
1846       CASE_MATHFN (BUILT_IN_ERF)
1847       CASE_MATHFN (BUILT_IN_ERFC)
1848       CASE_MATHFN (BUILT_IN_EXP)
1849       CASE_MATHFN (BUILT_IN_EXP10)
1850       CASE_MATHFN (BUILT_IN_EXP2)
1851       CASE_MATHFN (BUILT_IN_EXPM1)
1852       CASE_MATHFN (BUILT_IN_FABS)
1853       CASE_MATHFN (BUILT_IN_FDIM)
1854       CASE_MATHFN (BUILT_IN_FLOOR)
1855       CASE_MATHFN (BUILT_IN_FMA)
1856       CASE_MATHFN (BUILT_IN_FMAX)
1857       CASE_MATHFN (BUILT_IN_FMIN)
1858       CASE_MATHFN (BUILT_IN_FMOD)
1859       CASE_MATHFN (BUILT_IN_FREXP)
1860       CASE_MATHFN (BUILT_IN_GAMMA)
1861       CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1862       CASE_MATHFN (BUILT_IN_HUGE_VAL)
1863       CASE_MATHFN (BUILT_IN_HYPOT)
1864       CASE_MATHFN (BUILT_IN_ILOGB)
1865       CASE_MATHFN (BUILT_IN_INF)
1866       CASE_MATHFN (BUILT_IN_ISINF)
1867       CASE_MATHFN (BUILT_IN_J0)
1868       CASE_MATHFN (BUILT_IN_J1)
1869       CASE_MATHFN (BUILT_IN_JN)
1870       CASE_MATHFN (BUILT_IN_LCEIL)
1871       CASE_MATHFN (BUILT_IN_LDEXP)
1872       CASE_MATHFN (BUILT_IN_LFLOOR)
1873       CASE_MATHFN (BUILT_IN_LGAMMA)
1874       CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1875       CASE_MATHFN (BUILT_IN_LLCEIL)
1876       CASE_MATHFN (BUILT_IN_LLFLOOR)
1877       CASE_MATHFN (BUILT_IN_LLRINT)
1878       CASE_MATHFN (BUILT_IN_LLROUND)
1879       CASE_MATHFN (BUILT_IN_LOG)
1880       CASE_MATHFN (BUILT_IN_LOG10)
1881       CASE_MATHFN (BUILT_IN_LOG1P)
1882       CASE_MATHFN (BUILT_IN_LOG2)
1883       CASE_MATHFN (BUILT_IN_LOGB)
1884       CASE_MATHFN (BUILT_IN_LRINT)
1885       CASE_MATHFN (BUILT_IN_LROUND)
1886       CASE_MATHFN (BUILT_IN_MODF)
1887       CASE_MATHFN (BUILT_IN_NAN)
1888       CASE_MATHFN (BUILT_IN_NANS)
1889       CASE_MATHFN (BUILT_IN_NEARBYINT)
1890       CASE_MATHFN (BUILT_IN_NEXTAFTER)
1891       CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1892       CASE_MATHFN (BUILT_IN_POW)
1893       CASE_MATHFN (BUILT_IN_POWI)
1894       CASE_MATHFN (BUILT_IN_POW10)
1895       CASE_MATHFN (BUILT_IN_REMAINDER)
1896       CASE_MATHFN (BUILT_IN_REMQUO)
1897       CASE_MATHFN (BUILT_IN_RINT)
1898       CASE_MATHFN (BUILT_IN_ROUND)
1899       CASE_MATHFN (BUILT_IN_SCALB)
1900       CASE_MATHFN (BUILT_IN_SCALBLN)
1901       CASE_MATHFN (BUILT_IN_SCALBN)
1902       CASE_MATHFN (BUILT_IN_SIGNBIT)
1903       CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1904       CASE_MATHFN (BUILT_IN_SIN)
1905       CASE_MATHFN (BUILT_IN_SINCOS)
1906       CASE_MATHFN (BUILT_IN_SINH)
1907       CASE_MATHFN (BUILT_IN_SQRT)
1908       CASE_MATHFN (BUILT_IN_TAN)
1909       CASE_MATHFN (BUILT_IN_TANH)
1910       CASE_MATHFN (BUILT_IN_TGAMMA)
1911       CASE_MATHFN (BUILT_IN_TRUNC)
1912       CASE_MATHFN (BUILT_IN_Y0)
1913       CASE_MATHFN (BUILT_IN_Y1)
1914       CASE_MATHFN (BUILT_IN_YN)
1915
1916       default:
1917         return NULL_TREE;
1918       }
1919
1920   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1921     return fn_arr[fcode];
1922   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1923     return fn_arr[fcodef];
1924   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1925     return fn_arr[fcodel];
1926   else
1927     return NULL_TREE;
1928 }
1929
1930 /* Like mathfn_built_in_1(), but always use the implicit array.  */
1931
1932 tree
1933 mathfn_built_in (tree type, enum built_in_function fn)
1934 {
1935   return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1936 }
1937
1938 /* If errno must be maintained, expand the RTL to check if the result,
1939    TARGET, of a built-in function call, EXP, is NaN, and if so set
1940    errno to EDOM.  */
1941
1942 static void
1943 expand_errno_check (tree exp, rtx target)
1944 {
1945   rtx lab = gen_label_rtx ();
1946
1947   /* Test the result; if it is NaN, set errno=EDOM because
1948      the argument was not in the domain.  */
1949   do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1950                            NULL_RTX, NULL_RTX, lab,
1951                            /* The jump is very likely.  */
1952                            REG_BR_PROB_BASE - (REG_BR_PROB_BASE / 2000 - 1));
1953
1954 #ifdef TARGET_EDOM
1955   /* If this built-in doesn't throw an exception, set errno directly.  */
1956   if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1957     {
1958 #ifdef GEN_ERRNO_RTX
1959       rtx errno_rtx = GEN_ERRNO_RTX;
1960 #else
1961       rtx errno_rtx
1962           = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1963 #endif
1964       emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1965       emit_label (lab);
1966       return;
1967     }
1968 #endif
1969
1970   /* Make sure the library call isn't expanded as a tail call.  */
1971   CALL_EXPR_TAILCALL (exp) = 0;
1972
1973   /* We can't set errno=EDOM directly; let the library call do it.
1974      Pop the arguments right away in case the call gets deleted.  */
1975   NO_DEFER_POP;
1976   expand_call (exp, target, 0);
1977   OK_DEFER_POP;
1978   emit_label (lab);
1979 }
1980
1981 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1982    Return NULL_RTX if a normal call should be emitted rather than expanding
1983    the function in-line.  EXP is the expression that is a call to the builtin
1984    function; if convenient, the result should be placed in TARGET.
1985    SUBTARGET may be used as the target for computing one of EXP's operands.  */
1986
1987 static rtx
1988 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1989 {
1990   optab builtin_optab;
1991   rtx op0, insns;
1992   tree fndecl = get_callee_fndecl (exp);
1993   enum machine_mode mode;
1994   bool errno_set = false;
1995   tree arg;
1996
1997   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1998     return NULL_RTX;
1999
2000   arg = CALL_EXPR_ARG (exp, 0);
2001
2002   switch (DECL_FUNCTION_CODE (fndecl))
2003     {
2004     CASE_FLT_FN (BUILT_IN_SQRT):
2005       errno_set = ! tree_expr_nonnegative_p (arg);
2006       builtin_optab = sqrt_optab;
2007       break;
2008     CASE_FLT_FN (BUILT_IN_EXP):
2009       errno_set = true; builtin_optab = exp_optab; break;
2010     CASE_FLT_FN (BUILT_IN_EXP10):
2011     CASE_FLT_FN (BUILT_IN_POW10):
2012       errno_set = true; builtin_optab = exp10_optab; break;
2013     CASE_FLT_FN (BUILT_IN_EXP2):
2014       errno_set = true; builtin_optab = exp2_optab; break;
2015     CASE_FLT_FN (BUILT_IN_EXPM1):
2016       errno_set = true; builtin_optab = expm1_optab; break;
2017     CASE_FLT_FN (BUILT_IN_LOGB):
2018       errno_set = true; builtin_optab = logb_optab; break;
2019     CASE_FLT_FN (BUILT_IN_LOG):
2020       errno_set = true; builtin_optab = log_optab; break;
2021     CASE_FLT_FN (BUILT_IN_LOG10):
2022       errno_set = true; builtin_optab = log10_optab; break;
2023     CASE_FLT_FN (BUILT_IN_LOG2):
2024       errno_set = true; builtin_optab = log2_optab; break;
2025     CASE_FLT_FN (BUILT_IN_LOG1P):
2026       errno_set = true; builtin_optab = log1p_optab; break;
2027     CASE_FLT_FN (BUILT_IN_ASIN):
2028       builtin_optab = asin_optab; break;
2029     CASE_FLT_FN (BUILT_IN_ACOS):
2030       builtin_optab = acos_optab; break;
2031     CASE_FLT_FN (BUILT_IN_TAN):
2032       builtin_optab = tan_optab; break;
2033     CASE_FLT_FN (BUILT_IN_ATAN):
2034       builtin_optab = atan_optab; break;
2035     CASE_FLT_FN (BUILT_IN_FLOOR):
2036       builtin_optab = floor_optab; break;
2037     CASE_FLT_FN (BUILT_IN_CEIL):
2038       builtin_optab = ceil_optab; break;
2039     CASE_FLT_FN (BUILT_IN_TRUNC):
2040       builtin_optab = btrunc_optab; break;
2041     CASE_FLT_FN (BUILT_IN_ROUND):
2042       builtin_optab = round_optab; break;
2043     CASE_FLT_FN (BUILT_IN_NEARBYINT):
2044       builtin_optab = nearbyint_optab;
2045       if (flag_trapping_math)
2046         break;
2047       /* Else fallthrough and expand as rint.  */
2048     CASE_FLT_FN (BUILT_IN_RINT):
2049       builtin_optab = rint_optab; break;
2050     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
2051       builtin_optab = significand_optab; break;
2052     default:
2053       gcc_unreachable ();
2054     }
2055
2056   /* Make a suitable register to place result in.  */
2057   mode = TYPE_MODE (TREE_TYPE (exp));
2058
2059   if (! flag_errno_math || ! HONOR_NANS (mode))
2060     errno_set = false;
2061
2062   /* Before working hard, check whether the instruction is available.  */
2063   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2064     {
2065       target = gen_reg_rtx (mode);
2066
2067       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2068          need to expand the argument again.  This way, we will not perform
2069          side-effects more the once.  */
2070       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2071
2072       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2073
2074       start_sequence ();
2075
2076       /* Compute into TARGET.
2077          Set TARGET to wherever the result comes back.  */
2078       target = expand_unop (mode, builtin_optab, op0, target, 0);
2079
2080       if (target != 0)
2081         {
2082           if (errno_set)
2083             expand_errno_check (exp, target);
2084
2085           /* Output the entire sequence.  */
2086           insns = get_insns ();
2087           end_sequence ();
2088           emit_insn (insns);
2089           return target;
2090         }
2091
2092       /* If we were unable to expand via the builtin, stop the sequence
2093          (without outputting the insns) and call to the library function
2094          with the stabilized argument list.  */
2095       end_sequence ();
2096     }
2097
2098   return expand_call (exp, target, target == const0_rtx);
2099 }
2100
2101 /* Expand a call to the builtin binary math functions (pow and atan2).
2102    Return NULL_RTX if a normal call should be emitted rather than expanding the
2103    function in-line.  EXP is the expression that is a call to the builtin
2104    function; if convenient, the result should be placed in TARGET.
2105    SUBTARGET may be used as the target for computing one of EXP's
2106    operands.  */
2107
2108 static rtx
2109 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2110 {
2111   optab builtin_optab;
2112   rtx op0, op1, insns;
2113   int op1_type = REAL_TYPE;
2114   tree fndecl = get_callee_fndecl (exp);
2115   tree arg0, arg1;
2116   enum machine_mode mode;
2117   bool errno_set = true;
2118
2119   switch (DECL_FUNCTION_CODE (fndecl))
2120     {
2121     CASE_FLT_FN (BUILT_IN_SCALBN):
2122     CASE_FLT_FN (BUILT_IN_SCALBLN):
2123     CASE_FLT_FN (BUILT_IN_LDEXP):
2124       op1_type = INTEGER_TYPE;
2125     default:
2126       break;
2127     }
2128
2129   if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2130     return NULL_RTX;
2131
2132   arg0 = CALL_EXPR_ARG (exp, 0);
2133   arg1 = CALL_EXPR_ARG (exp, 1);
2134
2135   switch (DECL_FUNCTION_CODE (fndecl))
2136     {
2137     CASE_FLT_FN (BUILT_IN_POW):
2138       builtin_optab = pow_optab; break;
2139     CASE_FLT_FN (BUILT_IN_ATAN2):
2140       builtin_optab = atan2_optab; break;
2141     CASE_FLT_FN (BUILT_IN_SCALB):
2142       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2143         return 0;
2144       builtin_optab = scalb_optab; break;
2145     CASE_FLT_FN (BUILT_IN_SCALBN):
2146     CASE_FLT_FN (BUILT_IN_SCALBLN):
2147       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2148         return 0;
2149     /* Fall through... */
2150     CASE_FLT_FN (BUILT_IN_LDEXP):
2151       builtin_optab = ldexp_optab; break;
2152     CASE_FLT_FN (BUILT_IN_FMOD):
2153       builtin_optab = fmod_optab; break;
2154     CASE_FLT_FN (BUILT_IN_REMAINDER):
2155     CASE_FLT_FN (BUILT_IN_DREM):
2156       builtin_optab = remainder_optab; break;
2157     default:
2158       gcc_unreachable ();
2159     }
2160
2161   /* Make a suitable register to place result in.  */
2162   mode = TYPE_MODE (TREE_TYPE (exp));
2163
2164   /* Before working hard, check whether the instruction is available.  */
2165   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2166     return NULL_RTX;
2167
2168   target = gen_reg_rtx (mode);
2169
2170   if (! flag_errno_math || ! HONOR_NANS (mode))
2171     errno_set = false;
2172
2173   /* Always stabilize the argument list.  */
2174   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2175   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2176
2177   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2178   op1 = expand_normal (arg1);
2179
2180   start_sequence ();
2181
2182   /* Compute into TARGET.
2183      Set TARGET to wherever the result comes back.  */
2184   target = expand_binop (mode, builtin_optab, op0, op1,
2185                          target, 0, OPTAB_DIRECT);
2186
2187   /* If we were unable to expand via the builtin, stop the sequence
2188      (without outputting the insns) and call to the library function
2189      with the stabilized argument list.  */
2190   if (target == 0)
2191     {
2192       end_sequence ();
2193       return expand_call (exp, target, target == const0_rtx);
2194     }
2195
2196   if (errno_set)
2197     expand_errno_check (exp, target);
2198
2199   /* Output the entire sequence.  */
2200   insns = get_insns ();
2201   end_sequence ();
2202   emit_insn (insns);
2203
2204   return target;
2205 }
2206
2207 /* Expand a call to the builtin sin and cos math functions.
2208    Return NULL_RTX if a normal call should be emitted rather than expanding the
2209    function in-line.  EXP is the expression that is a call to the builtin
2210    function; if convenient, the result should be placed in TARGET.
2211    SUBTARGET may be used as the target for computing one of EXP's
2212    operands.  */
2213
2214 static rtx
2215 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2216 {
2217   optab builtin_optab;
2218   rtx op0, insns;
2219   tree fndecl = get_callee_fndecl (exp);
2220   enum machine_mode mode;
2221   tree arg;
2222
2223   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2224     return NULL_RTX;
2225
2226   arg = CALL_EXPR_ARG (exp, 0);
2227
2228   switch (DECL_FUNCTION_CODE (fndecl))
2229     {
2230     CASE_FLT_FN (BUILT_IN_SIN):
2231     CASE_FLT_FN (BUILT_IN_COS):
2232       builtin_optab = sincos_optab; break;
2233     default:
2234       gcc_unreachable ();
2235     }
2236
2237   /* Make a suitable register to place result in.  */
2238   mode = TYPE_MODE (TREE_TYPE (exp));
2239
2240   /* Check if sincos insn is available, otherwise fallback
2241      to sin or cos insn.  */
2242   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2243     switch (DECL_FUNCTION_CODE (fndecl))
2244       {
2245       CASE_FLT_FN (BUILT_IN_SIN):
2246         builtin_optab = sin_optab; break;
2247       CASE_FLT_FN (BUILT_IN_COS):
2248         builtin_optab = cos_optab; break;
2249       default:
2250         gcc_unreachable ();
2251       }
2252
2253   /* Before working hard, check whether the instruction is available.  */
2254   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2255     {
2256       target = gen_reg_rtx (mode);
2257
2258       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2259          need to expand the argument again.  This way, we will not perform
2260          side-effects more the once.  */
2261       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2262
2263       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2264
2265       start_sequence ();
2266
2267       /* Compute into TARGET.
2268          Set TARGET to wherever the result comes back.  */
2269       if (builtin_optab == sincos_optab)
2270         {
2271           int result;
2272
2273           switch (DECL_FUNCTION_CODE (fndecl))
2274             {
2275             CASE_FLT_FN (BUILT_IN_SIN):
2276               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2277               break;
2278             CASE_FLT_FN (BUILT_IN_COS):
2279               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2280               break;
2281             default:
2282               gcc_unreachable ();
2283             }
2284           gcc_assert (result);
2285         }
2286       else
2287         {
2288           target = expand_unop (mode, builtin_optab, op0, target, 0);
2289         }
2290
2291       if (target != 0)
2292         {
2293           /* Output the entire sequence.  */
2294           insns = get_insns ();
2295           end_sequence ();
2296           emit_insn (insns);
2297           return target;
2298         }
2299
2300       /* If we were unable to expand via the builtin, stop the sequence
2301          (without outputting the insns) and call to the library function
2302          with the stabilized argument list.  */
2303       end_sequence ();
2304     }
2305
2306   target = expand_call (exp, target, target == const0_rtx);
2307
2308   return target;
2309 }
2310
2311 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2312    return an RTL instruction code that implements the functionality.
2313    If that isn't possible or available return CODE_FOR_nothing.  */
2314
2315 static enum insn_code
2316 interclass_mathfn_icode (tree arg, tree fndecl)
2317 {
2318   bool errno_set = false;
2319   optab builtin_optab = 0;
2320   enum machine_mode mode;
2321
2322   switch (DECL_FUNCTION_CODE (fndecl))
2323     {
2324     CASE_FLT_FN (BUILT_IN_ILOGB):
2325       errno_set = true; builtin_optab = ilogb_optab; break;
2326     CASE_FLT_FN (BUILT_IN_ISINF):
2327       builtin_optab = isinf_optab; break;
2328     case BUILT_IN_ISNORMAL:
2329     case BUILT_IN_ISFINITE:
2330     CASE_FLT_FN (BUILT_IN_FINITE):
2331     case BUILT_IN_FINITED32:
2332     case BUILT_IN_FINITED64:
2333     case BUILT_IN_FINITED128:
2334     case BUILT_IN_ISINFD32:
2335     case BUILT_IN_ISINFD64:
2336     case BUILT_IN_ISINFD128:
2337       /* These builtins have no optabs (yet).  */
2338       break;
2339     default:
2340       gcc_unreachable ();
2341     }
2342
2343   /* There's no easy way to detect the case we need to set EDOM.  */
2344   if (flag_errno_math && errno_set)
2345     return CODE_FOR_nothing;
2346
2347   /* Optab mode depends on the mode of the input argument.  */
2348   mode = TYPE_MODE (TREE_TYPE (arg));
2349
2350   if (builtin_optab)
2351     return optab_handler (builtin_optab, mode);
2352   return CODE_FOR_nothing;
2353 }
2354
2355 /* Expand a call to one of the builtin math functions that operate on
2356    floating point argument and output an integer result (ilogb, isinf,
2357    isnan, etc).
2358    Return 0 if a normal call should be emitted rather than expanding the
2359    function in-line.  EXP is the expression that is a call to the builtin
2360    function; if convenient, the result should be placed in TARGET.
2361    SUBTARGET may be used as the target for computing one of EXP's operands.  */
2362
2363 static rtx
2364 expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
2365 {
2366   enum insn_code icode = CODE_FOR_nothing;
2367   rtx op0;
2368   tree fndecl = get_callee_fndecl (exp);
2369   enum machine_mode mode;
2370   tree arg;
2371
2372   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2373     return NULL_RTX;
2374
2375   arg = CALL_EXPR_ARG (exp, 0);
2376   icode = interclass_mathfn_icode (arg, fndecl);
2377   mode = TYPE_MODE (TREE_TYPE (arg));
2378
2379   if (icode != CODE_FOR_nothing)
2380     {
2381       rtx last = get_last_insn ();
2382       tree orig_arg = arg;
2383       /* Make a suitable register to place result in.  */
2384       if (!target
2385           || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp))
2386           || !insn_data[icode].operand[0].predicate (target, GET_MODE (target)))
2387          target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2388
2389       gcc_assert (insn_data[icode].operand[0].predicate
2390                   (target, GET_MODE (target)));
2391
2392       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2393          need to expand the argument again.  This way, we will not perform
2394          side-effects more the once.  */
2395       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2396
2397       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2398
2399       if (mode != GET_MODE (op0))
2400         op0 = convert_to_mode (mode, op0, 0);
2401
2402       /* Compute into TARGET.
2403          Set TARGET to wherever the result comes back.  */
2404       if (maybe_emit_unop_insn (icode, target, op0, UNKNOWN))
2405         return target;
2406       delete_insns_since (last);
2407       CALL_EXPR_ARG (exp, 0) = orig_arg;
2408     }
2409
2410   return NULL_RTX;
2411 }
2412
2413 /* Expand a call to the builtin sincos math function.
2414    Return NULL_RTX if a normal call should be emitted rather than expanding the
2415    function in-line.  EXP is the expression that is a call to the builtin
2416    function.  */
2417
2418 static rtx
2419 expand_builtin_sincos (tree exp)
2420 {
2421   rtx op0, op1, op2, target1, target2;
2422   enum machine_mode mode;
2423   tree arg, sinp, cosp;
2424   int result;
2425   location_t loc = EXPR_LOCATION (exp);
2426
2427   if (!validate_arglist (exp, REAL_TYPE,
2428                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2429     return NULL_RTX;
2430
2431   arg = CALL_EXPR_ARG (exp, 0);
2432   sinp = CALL_EXPR_ARG (exp, 1);
2433   cosp = CALL_EXPR_ARG (exp, 2);
2434
2435   /* Make a suitable register to place result in.  */
2436   mode = TYPE_MODE (TREE_TYPE (arg));
2437
2438   /* Check if sincos insn is available, otherwise emit the call.  */
2439   if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2440     return NULL_RTX;
2441
2442   target1 = gen_reg_rtx (mode);
2443   target2 = gen_reg_rtx (mode);
2444
2445   op0 = expand_normal (arg);
2446   op1 = expand_normal (build_fold_indirect_ref_loc (loc, sinp));
2447   op2 = expand_normal (build_fold_indirect_ref_loc (loc, cosp));
2448
2449   /* Compute into target1 and target2.
2450      Set TARGET to wherever the result comes back.  */
2451   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2452   gcc_assert (result);
2453
2454   /* Move target1 and target2 to the memory locations indicated
2455      by op1 and op2.  */
2456   emit_move_insn (op1, target1);
2457   emit_move_insn (op2, target2);
2458
2459   return const0_rtx;
2460 }
2461
2462 /* Expand a call to the internal cexpi builtin to the sincos math function.
2463    EXP is the expression that is a call to the builtin function; if convenient,
2464    the result should be placed in TARGET.  SUBTARGET may be used as the target
2465    for computing one of EXP's operands.  */
2466
2467 static rtx
2468 expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
2469 {
2470   tree fndecl = get_callee_fndecl (exp);
2471   tree arg, type;
2472   enum machine_mode mode;
2473   rtx op0, op1, op2;
2474   location_t loc = EXPR_LOCATION (exp);
2475
2476   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2477     return NULL_RTX;
2478
2479   arg = CALL_EXPR_ARG (exp, 0);
2480   type = TREE_TYPE (arg);
2481   mode = TYPE_MODE (TREE_TYPE (arg));
2482
2483   /* Try expanding via a sincos optab, fall back to emitting a libcall
2484      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2485      is only generated from sincos, cexp or if we have either of them.  */
2486   if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2487     {
2488       op1 = gen_reg_rtx (mode);
2489       op2 = gen_reg_rtx (mode);
2490
2491       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2492
2493       /* Compute into op1 and op2.  */
2494       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2495     }
2496   else if (TARGET_HAS_SINCOS)
2497     {
2498       tree call, fn = NULL_TREE;
2499       tree top1, top2;
2500       rtx op1a, op2a;
2501
2502       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2503         fn = built_in_decls[BUILT_IN_SINCOSF];
2504       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2505         fn = built_in_decls[BUILT_IN_SINCOS];
2506       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2507         fn = built_in_decls[BUILT_IN_SINCOSL];
2508       else
2509         gcc_unreachable ();
2510
2511       op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2512       op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2513       op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2514       op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2515       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2516       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2517
2518       /* Make sure not to fold the sincos call again.  */
2519       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2520       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2521                                       call, 3, arg, top1, top2));
2522     }
2523   else
2524     {
2525       tree call, fn = NULL_TREE, narg;
2526       tree ctype = build_complex_type (type);
2527
2528       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2529         fn = built_in_decls[BUILT_IN_CEXPF];
2530       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2531         fn = built_in_decls[BUILT_IN_CEXP];
2532       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2533         fn = built_in_decls[BUILT_IN_CEXPL];
2534       else
2535         gcc_unreachable ();
2536
2537       /* If we don't have a decl for cexp create one.  This is the
2538          friendliest fallback if the user calls __builtin_cexpi
2539          without full target C99 function support.  */
2540       if (fn == NULL_TREE)
2541         {
2542           tree fntype;
2543           const char *name = NULL;
2544
2545           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2546             name = "cexpf";
2547           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2548             name = "cexp";
2549           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2550             name = "cexpl";
2551
2552           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2553           fn = build_fn_decl (name, fntype);
2554         }
2555
2556       narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2557                           build_real (type, dconst0), arg);
2558
2559       /* Make sure not to fold the cexp call again.  */
2560       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2561       return expand_expr (build_call_nary (ctype, call, 1, narg),
2562                           target, VOIDmode, EXPAND_NORMAL);
2563     }
2564
2565   /* Now build the proper return type.  */
2566   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2567                               make_tree (TREE_TYPE (arg), op2),
2568                               make_tree (TREE_TYPE (arg), op1)),
2569                       target, VOIDmode, EXPAND_NORMAL);
2570 }
2571
2572 /* Conveniently construct a function call expression.  FNDECL names the
2573    function to be called, N is the number of arguments, and the "..."
2574    parameters are the argument expressions.  Unlike build_call_exr
2575    this doesn't fold the call, hence it will always return a CALL_EXPR.  */
2576
2577 static tree
2578 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2579 {
2580   va_list ap;
2581   tree fntype = TREE_TYPE (fndecl);
2582   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2583
2584   va_start (ap, n);
2585   fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2586   va_end (ap);
2587   SET_EXPR_LOCATION (fn, loc);
2588   return fn;
2589 }
2590
2591 /* Expand a call to one of the builtin rounding functions gcc defines
2592    as an extension (lfloor and lceil).  As these are gcc extensions we
2593    do not need to worry about setting errno to EDOM.
2594    If expanding via optab fails, lower expression to (int)(floor(x)).
2595    EXP is the expression that is a call to the builtin function;
2596    if convenient, the result should be placed in TARGET.  */
2597
2598 static rtx
2599 expand_builtin_int_roundingfn (tree exp, rtx target)
2600 {
2601   convert_optab builtin_optab;
2602   rtx op0, insns, tmp;
2603   tree fndecl = get_callee_fndecl (exp);
2604   enum built_in_function fallback_fn;
2605   tree fallback_fndecl;
2606   enum machine_mode mode;
2607   tree arg;
2608
2609   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2610     gcc_unreachable ();
2611
2612   arg = CALL_EXPR_ARG (exp, 0);
2613
2614   switch (DECL_FUNCTION_CODE (fndecl))
2615     {
2616     CASE_FLT_FN (BUILT_IN_LCEIL):
2617     CASE_FLT_FN (BUILT_IN_LLCEIL):
2618       builtin_optab = lceil_optab;
2619       fallback_fn = BUILT_IN_CEIL;
2620       break;
2621
2622     CASE_FLT_FN (BUILT_IN_LFLOOR):
2623     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2624       builtin_optab = lfloor_optab;
2625       fallback_fn = BUILT_IN_FLOOR;
2626       break;
2627
2628     default:
2629       gcc_unreachable ();
2630     }
2631
2632   /* Make a suitable register to place result in.  */
2633   mode = TYPE_MODE (TREE_TYPE (exp));
2634
2635   target = gen_reg_rtx (mode);
2636
2637   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2638      need to expand the argument again.  This way, we will not perform
2639      side-effects more the once.  */
2640   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2641
2642   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2643
2644   start_sequence ();
2645
2646   /* Compute into TARGET.  */
2647   if (expand_sfix_optab (target, op0, builtin_optab))
2648     {
2649       /* Output the entire sequence.  */
2650       insns = get_insns ();
2651       end_sequence ();
2652       emit_insn (insns);
2653       return target;
2654     }
2655
2656   /* If we were unable to expand via the builtin, stop the sequence
2657      (without outputting the insns).  */
2658   end_sequence ();
2659
2660   /* Fall back to floating point rounding optab.  */
2661   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2662
2663   /* For non-C99 targets we may end up without a fallback fndecl here
2664      if the user called __builtin_lfloor directly.  In this case emit
2665      a call to the floor/ceil variants nevertheless.  This should result
2666      in the best user experience for not full C99 targets.  */
2667   if (fallback_fndecl == NULL_TREE)
2668     {
2669       tree fntype;
2670       const char *name = NULL;
2671
2672       switch (DECL_FUNCTION_CODE (fndecl))
2673         {
2674         case BUILT_IN_LCEIL:
2675         case BUILT_IN_LLCEIL:
2676           name = "ceil";
2677           break;
2678         case BUILT_IN_LCEILF:
2679         case BUILT_IN_LLCEILF:
2680           name = "ceilf";
2681           break;
2682         case BUILT_IN_LCEILL:
2683         case BUILT_IN_LLCEILL:
2684           name = "ceill";
2685           break;
2686         case BUILT_IN_LFLOOR:
2687         case BUILT_IN_LLFLOOR:
2688           name = "floor";
2689           break;
2690         case BUILT_IN_LFLOORF:
2691         case BUILT_IN_LLFLOORF:
2692           name = "floorf";
2693           break;
2694         case BUILT_IN_LFLOORL:
2695         case BUILT_IN_LLFLOORL:
2696           name = "floorl";
2697           break;
2698         default:
2699           gcc_unreachable ();
2700         }
2701
2702       fntype = build_function_type_list (TREE_TYPE (arg),
2703                                          TREE_TYPE (arg), NULL_TREE);
2704       fallback_fndecl = build_fn_decl (name, fntype);
2705     }
2706
2707   exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2708
2709   tmp = expand_normal (exp);
2710
2711   /* Truncate the result of floating point optab to integer
2712      via expand_fix ().  */
2713   target = gen_reg_rtx (mode);
2714   expand_fix (target, tmp, 0);
2715
2716   return target;
2717 }
2718
2719 /* Expand a call to one of the builtin math functions doing integer
2720    conversion (lrint).
2721    Return 0 if a normal call should be emitted rather than expanding the
2722    function in-line.  EXP is the expression that is a call to the builtin
2723    function; if convenient, the result should be placed in TARGET.  */
2724
2725 static rtx
2726 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2727 {
2728   convert_optab builtin_optab;
2729   rtx op0, insns;
2730   tree fndecl = get_callee_fndecl (exp);
2731   tree arg;
2732   enum machine_mode mode;
2733
2734   /* There's no easy way to detect the case we need to set EDOM.  */
2735   if (flag_errno_math)
2736     return NULL_RTX;
2737
2738   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2739      gcc_unreachable ();
2740
2741   arg = CALL_EXPR_ARG (exp, 0);
2742
2743   switch (DECL_FUNCTION_CODE (fndecl))
2744     {
2745     CASE_FLT_FN (BUILT_IN_LRINT):
2746     CASE_FLT_FN (BUILT_IN_LLRINT):
2747       builtin_optab = lrint_optab; break;
2748     CASE_FLT_FN (BUILT_IN_LROUND):
2749     CASE_FLT_FN (BUILT_IN_LLROUND):
2750       builtin_optab = lround_optab; break;
2751     default:
2752       gcc_unreachable ();
2753     }
2754
2755   /* Make a suitable register to place result in.  */
2756   mode = TYPE_MODE (TREE_TYPE (exp));
2757
2758   target = gen_reg_rtx (mode);
2759
2760   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2761      need to expand the argument again.  This way, we will not perform
2762      side-effects more the once.  */
2763   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2764
2765   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2766
2767   start_sequence ();
2768
2769   if (expand_sfix_optab (target, op0, builtin_optab))
2770     {
2771       /* Output the entire sequence.  */
2772       insns = get_insns ();
2773       end_sequence ();
2774       emit_insn (insns);
2775       return target;
2776     }
2777
2778   /* If we were unable to expand via the builtin, stop the sequence
2779      (without outputting the insns) and call to the library function
2780      with the stabilized argument list.  */
2781   end_sequence ();
2782
2783   target = expand_call (exp, target, target == const0_rtx);
2784
2785   return target;
2786 }
2787
2788 /* To evaluate powi(x,n), the floating point value x raised to the
2789    constant integer exponent n, we use a hybrid algorithm that
2790    combines the "window method" with look-up tables.  For an
2791    introduction to exponentiation algorithms and "addition chains",
2792    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2793    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2794    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2795    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2796
2797 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2798    multiplications to inline before calling the system library's pow
2799    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2800    so this default never requires calling pow, powf or powl.  */
2801
2802 #ifndef POWI_MAX_MULTS
2803 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2804 #endif
2805
2806 /* The size of the "optimal power tree" lookup table.  All
2807    exponents less than this value are simply looked up in the
2808    powi_table below.  This threshold is also used to size the
2809    cache of pseudo registers that hold intermediate results.  */
2810 #define POWI_TABLE_SIZE 256
2811
2812 /* The size, in bits of the window, used in the "window method"
2813    exponentiation algorithm.  This is equivalent to a radix of
2814    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2815 #define POWI_WINDOW_SIZE 3
2816
2817 /* The following table is an efficient representation of an
2818    "optimal power tree".  For each value, i, the corresponding
2819    value, j, in the table states than an optimal evaluation
2820    sequence for calculating pow(x,i) can be found by evaluating
2821    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2822    100 integers is given in Knuth's "Seminumerical algorithms".  */
2823
2824 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2825   {
2826       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2827       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2828       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2829      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2830      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2831      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2832      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2833      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2834      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2835      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2836      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2837      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2838      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2839      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2840      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2841      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2842      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2843      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2844      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2845      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2846      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2847      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2848      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2849      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2850      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2851     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2852     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2853     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2854     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2855     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2856     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2857     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2858   };
2859
2860
2861 /* Return the number of multiplications required to calculate
2862    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2863    subroutine of powi_cost.  CACHE is an array indicating
2864    which exponents have already been calculated.  */
2865
2866 static int
2867 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2868 {
2869   /* If we've already calculated this exponent, then this evaluation
2870      doesn't require any additional multiplications.  */
2871   if (cache[n])
2872     return 0;
2873
2874   cache[n] = true;
2875   return powi_lookup_cost (n - powi_table[n], cache)
2876          + powi_lookup_cost (powi_table[n], cache) + 1;
2877 }
2878
2879 /* Return the number of multiplications required to calculate
2880    powi(x,n) for an arbitrary x, given the exponent N.  This
2881    function needs to be kept in sync with expand_powi below.  */
2882
2883 static int
2884 powi_cost (HOST_WIDE_INT n)
2885 {
2886   bool cache[POWI_TABLE_SIZE];
2887   unsigned HOST_WIDE_INT digit;
2888   unsigned HOST_WIDE_INT val;
2889   int result;
2890
2891   if (n == 0)
2892     return 0;
2893
2894   /* Ignore the reciprocal when calculating the cost.  */
2895   val = (n < 0) ? -n : n;
2896
2897   /* Initialize the exponent cache.  */
2898   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2899   cache[1] = true;
2900
2901   result = 0;
2902
2903   while (val >= POWI_TABLE_SIZE)
2904     {
2905       if (val & 1)
2906         {
2907           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2908           result += powi_lookup_cost (digit, cache)
2909                     + POWI_WINDOW_SIZE + 1;
2910           val >>= POWI_WINDOW_SIZE;
2911         }
2912       else
2913         {
2914           val >>= 1;
2915           result++;
2916         }
2917     }
2918
2919   return result + powi_lookup_cost (val, cache);
2920 }
2921
2922 /* Recursive subroutine of expand_powi.  This function takes the array,
2923    CACHE, of already calculated exponents and an exponent N and returns
2924    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2925
2926 static rtx
2927 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2928 {
2929   unsigned HOST_WIDE_INT digit;
2930   rtx target, result;
2931   rtx op0, op1;
2932
2933   if (n < POWI_TABLE_SIZE)
2934     {
2935       if (cache[n])
2936         return cache[n];
2937
2938       target = gen_reg_rtx (mode);
2939       cache[n] = target;
2940
2941       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2942       op1 = expand_powi_1 (mode, powi_table[n], cache);
2943     }
2944   else if (n & 1)
2945     {
2946       target = gen_reg_rtx (mode);
2947       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2948       op0 = expand_powi_1 (mode, n - digit, cache);
2949       op1 = expand_powi_1 (mode, digit, cache);
2950     }
2951   else
2952     {
2953       target = gen_reg_rtx (mode);
2954       op0 = expand_powi_1 (mode, n >> 1, cache);
2955       op1 = op0;
2956     }
2957
2958   result = expand_mult (mode, op0, op1, target, 0);
2959   if (result != target)
2960     emit_move_insn (target, result);
2961   return target;
2962 }
2963
2964 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
2965    floating point operand in mode MODE, and N is the exponent.  This
2966    function needs to be kept in sync with powi_cost above.  */
2967
2968 static rtx
2969 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2970 {
2971   rtx cache[POWI_TABLE_SIZE];
2972   rtx result;
2973
2974   if (n == 0)
2975     return CONST1_RTX (mode);
2976
2977   memset (cache, 0, sizeof (cache));
2978   cache[1] = x;
2979
2980   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2981
2982   /* If the original exponent was negative, reciprocate the result.  */
2983   if (n < 0)
2984     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2985                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2986
2987   return result;
2988 }
2989
2990 /* Fold a builtin function call to pow, powf, or powl into a series of sqrts or
2991    cbrts.  Return NULL_RTX if no simplification can be made or expand the tree
2992    if we can simplify it.  */
2993 static rtx
2994 expand_builtin_pow_root (location_t loc, tree arg0, tree arg1, tree type,
2995                          rtx subtarget)
2996 {
2997   if (TREE_CODE (arg1) == REAL_CST
2998       && !TREE_OVERFLOW (arg1)
2999       && flag_unsafe_math_optimizations)
3000     {
3001       enum machine_mode mode = TYPE_MODE (type);
3002       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
3003       tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
3004       REAL_VALUE_TYPE c = TREE_REAL_CST (arg1);
3005       tree op = NULL_TREE;
3006
3007       if (sqrtfn)
3008         {
3009           /* Optimize pow (x, 0.5) into sqrt.  */
3010           if (REAL_VALUES_EQUAL (c, dconsthalf))
3011             op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3012
3013           else
3014             {
3015               REAL_VALUE_TYPE dconst1_4 = dconst1;
3016               REAL_VALUE_TYPE dconst3_4;
3017               SET_REAL_EXP (&dconst1_4, REAL_EXP (&dconst1_4) - 2);
3018
3019               real_from_integer (&dconst3_4, VOIDmode, 3, 0, 0);
3020               SET_REAL_EXP (&dconst3_4, REAL_EXP (&dconst3_4) - 2);
3021
3022               /* Optimize pow (x, 0.25) into sqrt (sqrt (x)).  Assume on most
3023                  machines that a builtin sqrt instruction is smaller than a
3024                  call to pow with 0.25, so do this optimization even if
3025                  -Os.  */
3026               if (REAL_VALUES_EQUAL (c, dconst1_4))
3027                 {
3028                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3029                   op = build_call_nofold_loc (loc, sqrtfn, 1, op);
3030                 }
3031
3032               /* Optimize pow (x, 0.75) = sqrt (x) * sqrt (sqrt (x)) unless we
3033                  are optimizing for space.  */
3034               else if (optimize_insn_for_speed_p ()
3035                        && !TREE_SIDE_EFFECTS (arg0)
3036                        && REAL_VALUES_EQUAL (c, dconst3_4))
3037                 {
3038                   tree sqrt1 = build_call_expr_loc (loc, sqrtfn, 1, arg0);
3039                   tree sqrt2 = builtin_save_expr (sqrt1);
3040                   tree sqrt3 = build_call_expr_loc (loc, sqrtfn, 1, sqrt1);
3041                   op = fold_build2_loc (loc, MULT_EXPR, type, sqrt2, sqrt3);
3042                 }
3043             }
3044         }
3045
3046       /* Check whether we can do cbrt insstead of pow (x, 1./3.) and
3047          cbrt/sqrts instead of pow (x, 1./6.).  */
3048       if (cbrtfn && ! op
3049           && (tree_expr_nonnegative_p (arg0) || !HONOR_NANS (mode)))
3050         {
3051           /* First try 1/3.  */
3052           REAL_VALUE_TYPE dconst1_3
3053             = real_value_truncate (mode, dconst_third ());
3054
3055           if (REAL_VALUES_EQUAL (c, dconst1_3))
3056             op = build_call_nofold_loc (loc, cbrtfn, 1, arg0);
3057
3058               /* Now try 1/6.  */
3059           else if (optimize_insn_for_speed_p ())
3060             {
3061               REAL_VALUE_TYPE dconst1_6 = dconst1_3;
3062               SET_REAL_EXP (&dconst1_6, REAL_EXP (&dconst1_6) - 1);
3063
3064               if (REAL_VALUES_EQUAL (c, dconst1_6))
3065                 {
3066                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3067                   op = build_call_nofold_loc (loc, cbrtfn, 1, op);
3068                 }
3069             }
3070         }
3071
3072       if (op)
3073         return expand_expr (op, subtarget, mode, EXPAND_NORMAL);
3074     }
3075
3076   return NULL_RTX;
3077 }
3078
3079 /* Expand a call to the pow built-in mathematical function.  Return NULL_RTX if
3080    a normal call should be emitted rather than expanding the function
3081    in-line.  EXP is the expression that is a call to the builtin
3082    function; if convenient, the result should be placed in TARGET.  */
3083
3084 static rtx
3085 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
3086 {
3087   tree arg0, arg1;
3088   tree fn, narg0;
3089   tree type = TREE_TYPE (exp);
3090   REAL_VALUE_TYPE cint, c, c2;
3091   HOST_WIDE_INT n;
3092   rtx op, op2;
3093   enum machine_mode mode = TYPE_MODE (type);
3094
3095   if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
3096     return NULL_RTX;
3097
3098   arg0 = CALL_EXPR_ARG (exp, 0);
3099   arg1 = CALL_EXPR_ARG (exp, 1);
3100
3101   if (TREE_CODE (arg1) != REAL_CST
3102       || TREE_OVERFLOW (arg1))
3103     return expand_builtin_mathfn_2 (exp, target, subtarget);
3104
3105   /* Handle constant exponents.  */
3106
3107   /* For integer valued exponents we can expand to an optimal multiplication
3108      sequence using expand_powi.  */
3109   c = TREE_REAL_CST (arg1);
3110   n = real_to_integer (&c);
3111   real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3112   if (real_identical (&c, &cint)
3113       && ((n >= -1 && n <= 2)
3114           || (flag_unsafe_math_optimizations
3115               && optimize_insn_for_speed_p ()
3116               && powi_cost (n) <= POWI_MAX_MULTS)))
3117     {
3118       op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3119       if (n != 1)
3120         {
3121           op = force_reg (mode, op);
3122           op = expand_powi (op, mode, n);
3123         }
3124       return op;
3125     }
3126
3127   narg0 = builtin_save_expr (arg0);
3128
3129   /* If the exponent is not integer valued, check if it is half of an integer.
3130      In this case we can expand to sqrt (x) * x**(n/2).  */
3131   fn = mathfn_built_in (type, BUILT_IN_SQRT);
3132   if (fn != NULL_TREE)
3133     {
3134       real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
3135       n = real_to_integer (&c2);
3136       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3137       if (real_identical (&c2, &cint)
3138           && ((flag_unsafe_math_optimizations
3139                && optimize_insn_for_speed_p ()
3140                && powi_cost (n/2) <= POWI_MAX_MULTS)
3141               /* Even the c == 0.5 case cannot be done unconditionally
3142                  when we need to preserve signed zeros, as
3143                  pow (-0, 0.5) is +0, while sqrt(-0) is -0.  */
3144               || (!HONOR_SIGNED_ZEROS (mode) && n == 1)
3145               /* For c == 1.5 we can assume that x * sqrt (x) is always
3146                  smaller than pow (x, 1.5) if sqrt will not be expanded
3147                  as a call.  */
3148               || (n == 3
3149                   && optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)))
3150         {
3151           tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3152                                                   narg0);
3153           /* Use expand_expr in case the newly built call expression
3154              was folded to a non-call.  */
3155           op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
3156           if (n != 1)
3157             {
3158               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3159               op2 = force_reg (mode, op2);
3160               op2 = expand_powi (op2, mode, abs (n / 2));
3161               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3162                                         0, OPTAB_LIB_WIDEN);
3163               /* If the original exponent was negative, reciprocate the
3164                  result.  */
3165               if (n < 0)
3166                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3167                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3168             }
3169           return op;
3170         }
3171     }
3172
3173   /* Check whether we can do a series of sqrt or cbrt's instead of the pow
3174      call.  */
3175   op = expand_builtin_pow_root (EXPR_LOCATION (exp), arg0, arg1, type,
3176                                 subtarget);
3177   if (op)
3178     return op;
3179
3180   /* Try if the exponent is a third of an integer.  In this case
3181      we can expand to x**(n/3) * cbrt(x)**(n%3).  As cbrt (x) is
3182      different from pow (x, 1./3.) due to rounding and behavior
3183      with negative x we need to constrain this transformation to
3184      unsafe math and positive x or finite math.  */
3185   fn = mathfn_built_in (type, BUILT_IN_CBRT);
3186   if (fn != NULL_TREE
3187       && flag_unsafe_math_optimizations
3188       && (tree_expr_nonnegative_p (arg0)
3189           || !HONOR_NANS (mode)))
3190     {
3191       REAL_VALUE_TYPE dconst3;
3192       real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3193       real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3194       real_round (&c2, mode, &c2);
3195       n = real_to_integer (&c2);
3196       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3197       real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3198       real_convert (&c2, mode, &c2);
3199       if (real_identical (&c2, &c)
3200           && ((optimize_insn_for_speed_p ()
3201                && powi_cost (n/3) <= POWI_MAX_MULTS)
3202               || n == 1))
3203         {
3204           tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3205                                                   narg0);
3206           op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3207           if (abs (n) % 3 == 2)
3208             op = expand_simple_binop (mode, MULT, op, op, op,
3209                                       0, OPTAB_LIB_WIDEN);
3210           if (n != 1)
3211             {
3212               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3213               op2 = force_reg (mode, op2);
3214               op2 = expand_powi (op2, mode, abs (n / 3));
3215               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3216                                         0, OPTAB_LIB_WIDEN);
3217               /* If the original exponent was negative, reciprocate the
3218                  result.  */
3219               if (n < 0)
3220                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3221                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3222             }
3223           return op;
3224         }
3225     }
3226
3227   /* Fall back to optab expansion.  */
3228   return expand_builtin_mathfn_2 (exp, target, subtarget);
3229 }
3230
3231 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
3232    a normal call should be emitted rather than expanding the function
3233    in-line.  EXP is the expression that is a call to the builtin
3234    function; if convenient, the result should be placed in TARGET.  */
3235
3236 static rtx
3237 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
3238 {
3239   tree arg0, arg1;
3240   rtx op0, op1;
3241   enum machine_mode mode;
3242   enum machine_mode mode2;
3243
3244   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3245     return NULL_RTX;
3246
3247   arg0 = CALL_EXPR_ARG (exp, 0);
3248   arg1 = CALL_EXPR_ARG (exp, 1);
3249   mode = TYPE_MODE (TREE_TYPE (exp));
3250
3251   /* Handle constant power.  */
3252
3253   if (TREE_CODE (arg1) == INTEGER_CST
3254       && !TREE_OVERFLOW (arg1))
3255     {
3256       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3257
3258       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3259          Otherwise, check the number of multiplications required.  */
3260       if ((TREE_INT_CST_HIGH (arg1) == 0
3261            || TREE_INT_CST_HIGH (arg1) == -1)
3262           && ((n >= -1 && n <= 2)
3263               || (optimize_insn_for_speed_p ()
3264                   && powi_cost (n) <= POWI_MAX_MULTS)))
3265         {
3266           op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3267           op0 = force_reg (mode, op0);
3268           return expand_powi (op0, mode, n);
3269         }
3270     }
3271
3272   /* Emit a libcall to libgcc.  */
3273
3274   /* Mode of the 2nd argument must match that of an int.  */
3275   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3276
3277   if (target == NULL_RTX)
3278     target = gen_reg_rtx (mode);
3279
3280   op0 = expand_expr (arg0, subtarget, mode, EXPAND_NORMAL);
3281   if (GET_MODE (op0) != mode)
3282     op0 = convert_to_mode (mode, op0, 0);
3283   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3284   if (GET_MODE (op1) != mode2)
3285     op1 = convert_to_mode (mode2, op1, 0);
3286
3287   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3288                                     target, LCT_CONST, mode, 2,
3289                                     op0, mode, op1, mode2);
3290
3291   return target;
3292 }
3293
3294 /* Expand expression EXP which is a call to the strlen builtin.  Return
3295    NULL_RTX if we failed the caller should emit a normal call, otherwise
3296    try to get the result in TARGET, if convenient.  */
3297
3298 static rtx
3299 expand_builtin_strlen (tree exp, rtx target,
3300                        enum machine_mode target_mode)
3301 {
3302   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3303     return NULL_RTX;
3304   else
3305     {
3306       rtx pat;
3307       tree len;
3308       tree src = CALL_EXPR_ARG (exp, 0);
3309       rtx result, src_reg, char_rtx, before_strlen;
3310       enum machine_mode insn_mode = target_mode, char_mode;
3311       enum insn_code icode = CODE_FOR_nothing;
3312       unsigned int align;
3313
3314       /* If the length can be computed at compile-time, return it.  */
3315       len = c_strlen (src, 0);
3316       if (len)
3317         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3318
3319       /* If the length can be computed at compile-time and is constant
3320          integer, but there are side-effects in src, evaluate
3321          src for side-effects, then return len.
3322          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3323          can be optimized into: i++; x = 3;  */
3324       len = c_strlen (src, 1);
3325       if (len && TREE_CODE (len) == INTEGER_CST)
3326         {
3327           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3328           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3329         }
3330
3331       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3332
3333       /* If SRC is not a pointer type, don't do this operation inline.  */
3334       if (align == 0)
3335         return NULL_RTX;
3336
3337       /* Bail out if we can't compute strlen in the right mode.  */
3338       while (insn_mode != VOIDmode)
3339         {
3340           icode = optab_handler (strlen_optab, insn_mode);
3341           if (icode != CODE_FOR_nothing)
3342             break;
3343
3344           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3345         }
3346       if (insn_mode == VOIDmode)
3347         return NULL_RTX;
3348
3349       /* Make a place to write the result of the instruction.  */
3350       result = target;
3351       if (! (result != 0
3352              && REG_P (result)
3353              && GET_MODE (result) == insn_mode
3354              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3355         result = gen_reg_rtx (insn_mode);
3356
3357       /* Make a place to hold the source address.  We will not expand
3358          the actual source until we are sure that the expansion will
3359          not fail -- there are trees that cannot be expanded twice.  */
3360       src_reg = gen_reg_rtx (Pmode);
3361
3362       /* Mark the beginning of the strlen sequence so we can emit the
3363          source operand later.  */
3364       before_strlen = get_last_insn ();
3365
3366       char_rtx = const0_rtx;
3367       char_mode = insn_data[(int) icode].operand[2].mode;
3368       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3369                                                             char_mode))
3370         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3371
3372       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3373                              char_rtx, GEN_INT (align));
3374       if (! pat)
3375         return NULL_RTX;
3376       emit_insn (pat);
3377
3378       /* Now that we are assured of success, expand the source.  */
3379       start_sequence ();
3380       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3381       if (pat != src_reg)
3382         emit_move_insn (src_reg, pat);
3383       pat = get_insns ();
3384       end_sequence ();
3385
3386       if (before_strlen)
3387         emit_insn_after (pat, before_strlen);
3388       else
3389         emit_insn_before (pat, get_insns ());
3390
3391       /* Return the value in the proper mode for this function.  */
3392       if (GET_MODE (result) == target_mode)
3393         target = result;
3394       else if (target != 0)
3395         convert_move (target, result, 0);
3396       else
3397         target = convert_to_mode (target_mode, result, 0);
3398
3399       return target;
3400     }
3401 }
3402
3403 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3404    bytes from constant string DATA + OFFSET and return it as target
3405    constant.  */
3406
3407 static rtx
3408 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3409                          enum machine_mode mode)
3410 {
3411   const char *str = (const char *) data;
3412
3413   gcc_assert (offset >= 0
3414               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3415                   <= strlen (str) + 1));
3416
3417   return c_readstr (str + offset, mode);
3418 }
3419
3420 /* Expand a call EXP to the memcpy builtin.
3421    Return NULL_RTX if we failed, the caller should emit a normal call,
3422    otherwise try to get the result in TARGET, if convenient (and in
3423    mode MODE if that's convenient).  */
3424
3425 static rtx
3426 expand_builtin_memcpy (tree exp, rtx target)
3427 {
3428   if (!validate_arglist (exp,
3429                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3430     return NULL_RTX;
3431   else
3432     {
3433       tree dest = CALL_EXPR_ARG (exp, 0);
3434       tree src = CALL_EXPR_ARG (exp, 1);
3435       tree len = CALL_EXPR_ARG (exp, 2);
3436       const char *src_str;
3437       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3438       unsigned int dest_align
3439         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3440       rtx dest_mem, src_mem, dest_addr, len_rtx;
3441       HOST_WIDE_INT expected_size = -1;
3442       unsigned int expected_align = 0;
3443
3444       /* If DEST is not a pointer type, call the normal function.  */
3445       if (dest_align == 0)
3446         return NULL_RTX;
3447
3448       /* If either SRC is not a pointer type, don't do this
3449          operation in-line.  */
3450       if (src_align == 0)
3451         return NULL_RTX;
3452
3453       if (currently_expanding_gimple_stmt)
3454         stringop_block_profile (currently_expanding_gimple_stmt,
3455                                 &expected_align, &expected_size);
3456
3457       if (expected_align < dest_align)
3458         expected_align = dest_align;
3459       dest_mem = get_memory_rtx (dest, len);
3460       set_mem_align (dest_mem, dest_align);
3461       len_rtx = expand_normal (len);
3462       src_str = c_getstr (src);
3463
3464       /* If SRC is a string constant and block move would be done
3465          by pieces, we can avoid loading the string from memory
3466          and only stored the computed constants.  */
3467       if (src_str
3468           && CONST_INT_P (len_rtx)
3469           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3470           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3471                                   CONST_CAST (char *, src_str),
3472                                   dest_align, false))
3473         {
3474           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3475                                       builtin_memcpy_read_str,
3476                                       CONST_CAST (char *, src_str),
3477                                       dest_align, false, 0);
3478           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3479           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3480           return dest_mem;
3481         }
3482
3483       src_mem = get_memory_rtx (src, len);
3484       set_mem_align (src_mem, src_align);
3485
3486       /* Copy word part most expediently.  */
3487       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3488                                          CALL_EXPR_TAILCALL (exp)
3489                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3490                                          expected_align, expected_size);
3491
3492       if (dest_addr == 0)
3493         {
3494           dest_addr = force_operand (XEXP (dest_mem, 0), target);
3495           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3496         }
3497       return dest_addr;
3498     }
3499 }
3500
3501 /* Expand a call EXP to the mempcpy builtin.
3502    Return NULL_RTX if we failed; the caller should emit a normal call,
3503    otherwise try to get the result in TARGET, if convenient (and in
3504    mode MODE if that's convenient).  If ENDP is 0 return the
3505    destination pointer, if ENDP is 1 return the end pointer ala
3506    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3507    stpcpy.  */
3508
3509 static rtx
3510 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3511 {
3512   if (!validate_arglist (exp,
3513                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3514     return NULL_RTX;
3515   else
3516     {
3517       tree dest = CALL_EXPR_ARG (exp, 0);
3518       tree src = CALL_EXPR_ARG (exp, 1);
3519       tree len = CALL_EXPR_ARG (exp, 2);
3520       return expand_builtin_mempcpy_args (dest, src, len,
3521                                           target, mode, /*endp=*/ 1);
3522     }
3523 }
3524
3525 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3526    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3527    so that this can also be called without constructing an actual CALL_EXPR.
3528    The other arguments and return value are the same as for
3529    expand_builtin_mempcpy.  */
3530
3531 static rtx
3532 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3533                              rtx target, enum machine_mode mode, int endp)
3534 {
3535     /* If return value is ignored, transform mempcpy into memcpy.  */
3536   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3537     {
3538       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3539       tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3540                                            dest, src, len);
3541       return expand_expr (result, target, mode, EXPAND_NORMAL);
3542     }
3543   else
3544     {
3545       const char *src_str;
3546       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3547       unsigned int dest_align
3548         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3549       rtx dest_mem, src_mem, len_rtx;
3550
3551       /* If either SRC or DEST is not a pointer type, don't do this
3552          operation in-line.  */
3553       if (dest_align == 0 || src_align == 0)
3554         return NULL_RTX;
3555
3556       /* If LEN is not constant, call the normal function.  */
3557       if (! host_integerp (len, 1))
3558         return NULL_RTX;
3559
3560       len_rtx = expand_normal (len);
3561       src_str = c_getstr (src);
3562
3563       /* If SRC is a string constant and block move would be done
3564          by pieces, we can avoid loading the string from memory
3565          and only stored the computed constants.  */
3566       if (src_str
3567           && CONST_INT_P (len_rtx)
3568           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3569           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3570                                   CONST_CAST (char *, src_str),
3571                                   dest_align, false))
3572         {
3573           dest_mem = get_memory_rtx (dest, len);
3574           set_mem_align (dest_mem, dest_align);
3575           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3576                                       builtin_memcpy_read_str,
3577                                       CONST_CAST (char *, src_str),
3578                                       dest_align, false, endp);
3579           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3580           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3581           return dest_mem;
3582         }
3583
3584       if (CONST_INT_P (len_rtx)
3585           && can_move_by_pieces (INTVAL (len_rtx),
3586                                  MIN (dest_align, src_align)))
3587         {
3588           dest_mem = get_memory_rtx (dest, len);
3589           set_mem_align (dest_mem, dest_align);
3590           src_mem = get_memory_rtx (src, len);
3591           set_mem_align (src_mem, src_align);
3592           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3593                                      MIN (dest_align, src_align), endp);
3594           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3595           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3596           return dest_mem;
3597         }
3598
3599       return NULL_RTX;
3600     }
3601 }
3602
3603 #ifndef HAVE_movstr
3604 # define HAVE_movstr 0
3605 # define CODE_FOR_movstr CODE_FOR_nothing
3606 #endif
3607
3608 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3609    we failed, the caller should emit a normal call, otherwise try to
3610    get the result in TARGET, if convenient.  If ENDP is 0 return the
3611    destination pointer, if ENDP is 1 return the end pointer ala
3612    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3613    stpcpy.  */
3614
3615 static rtx
3616 expand_movstr (tree dest, tree src, rtx target, int endp)
3617 {
3618   rtx end;
3619   rtx dest_mem;
3620   rtx src_mem;
3621   rtx insn;
3622   const struct insn_data_d * data;
3623
3624   if (!HAVE_movstr)
3625     return NULL_RTX;
3626
3627   dest_mem = get_memory_rtx (dest, NULL);
3628   src_mem = get_memory_rtx (src, NULL);
3629   data = insn_data + CODE_FOR_movstr;
3630   if (!endp)
3631     {
3632       target = force_reg (Pmode, XEXP (dest_mem, 0));
3633       dest_mem = replace_equiv_address (dest_mem, target);
3634       end = gen_reg_rtx (Pmode);
3635     }
3636   else
3637     {
3638       if (target == 0
3639           || target == const0_rtx
3640           || ! (*data->operand[0].predicate) (target, Pmode))
3641         {
3642           end = gen_reg_rtx (Pmode);
3643           if (target != const0_rtx)
3644             target = end;
3645         }
3646       else
3647         end = target;
3648     }
3649
3650   if (data->operand[0].mode != VOIDmode)
3651     end = gen_lowpart (data->operand[0].mode, end);
3652
3653   insn = data->genfun (end, dest_mem, src_mem);
3654
3655   gcc_assert (insn);
3656
3657   emit_insn (insn);
3658
3659   /* movstr is supposed to set end to the address of the NUL
3660      terminator.  If the caller requested a mempcpy-like return value,
3661      adjust it.  */
3662   if (endp == 1 && target != const0_rtx)
3663     {
3664       rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3665       emit_move_insn (target, force_operand (tem, NULL_RTX));
3666     }
3667
3668   return target;
3669 }
3670
3671 /* Expand expression EXP, which is a call to the strcpy builtin.  Return
3672    NULL_RTX if we failed the caller should emit a normal call, otherwise
3673    try to get the result in TARGET, if convenient (and in mode MODE if that's
3674    convenient).  */
3675
3676 static rtx
3677 expand_builtin_strcpy (tree exp, rtx target)
3678 {
3679   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3680    {
3681      tree dest = CALL_EXPR_ARG (exp, 0);
3682      tree src = CALL_EXPR_ARG (exp, 1);
3683      return expand_builtin_strcpy_args (dest, src, target);
3684    }
3685    return NULL_RTX;
3686 }
3687
3688 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3689    arguments to the builtin_strcpy call DEST and SRC are broken out
3690    so that this can also be called without constructing an actual CALL_EXPR.
3691    The other arguments and return value are the same as for
3692    expand_builtin_strcpy.  */
3693
3694 static rtx
3695 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3696 {
3697   return expand_movstr (dest, src, target, /*endp=*/0);
3698 }
3699
3700 /* Expand a call EXP to the stpcpy builtin.
3701    Return NULL_RTX if we failed the caller should emit a normal call,
3702    otherwise try to get the result in TARGET, if convenient (and in
3703    mode MODE if that's convenient).  */
3704
3705 static rtx
3706 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3707 {
3708   tree dst, src;
3709   location_t loc = EXPR_LOCATION (exp);
3710
3711   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3712     return NULL_RTX;
3713
3714   dst = CALL_EXPR_ARG (exp, 0);
3715   src = CALL_EXPR_ARG (exp, 1);
3716
3717   /* If return value is ignored, transform stpcpy into strcpy.  */
3718   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3719     {
3720       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3721       tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3722       return expand_expr (result, target, mode, EXPAND_NORMAL);
3723     }
3724   else
3725     {
3726       tree len, lenp1;
3727       rtx ret;
3728
3729       /* Ensure we get an actual string whose length can be evaluated at
3730          compile-time, not an expression containing a string.  This is
3731          because the latter will potentially produce pessimized code
3732          when used to produce the return value.  */
3733       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3734         return expand_movstr (dst, src, target, /*endp=*/2);
3735
3736       lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3737       ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3738                                          target, mode, /*endp=*/2);
3739
3740       if (ret)
3741         return ret;
3742
3743       if (TREE_CODE (len) == INTEGER_CST)
3744         {
3745           rtx len_rtx = expand_normal (len);
3746
3747           if (CONST_INT_P (len_rtx))
3748             {
3749               ret = expand_builtin_strcpy_args (dst, src, target);
3750
3751               if (ret)
3752                 {
3753                   if (! target)
3754                     {
3755                       if (mode != VOIDmode)
3756                         target = gen_reg_rtx (mode);
3757                       else
3758                         target = gen_reg_rtx (GET_MODE (ret));
3759                     }
3760                   if (GET_MODE (target) != GET_MODE (ret))
3761                     ret = gen_lowpart (GET_MODE (target), ret);
3762
3763                   ret = plus_constant (ret, INTVAL (len_rtx));
3764                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3765                   gcc_assert (ret);
3766
3767                   return target;
3768                 }
3769             }
3770         }
3771
3772       return expand_movstr (dst, src, target, /*endp=*/2);
3773     }
3774 }
3775
3776 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3777    bytes from constant string DATA + OFFSET and return it as target
3778    constant.  */
3779
3780 rtx
3781 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3782                           enum machine_mode mode)
3783 {
3784   const char *str = (const char *) data;
3785
3786   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3787     return const0_rtx;
3788
3789   return c_readstr (str + offset, mode);
3790 }
3791
3792 /* Expand expression EXP, which is a call to the strncpy builtin.  Return
3793    NULL_RTX if we failed the caller should emit a normal call.  */
3794
3795 static rtx
3796 expand_builtin_strncpy (tree exp, rtx target)
3797 {
3798   location_t loc = EXPR_LOCATION (exp);
3799
3800   if (validate_arglist (exp,
3801                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3802     {
3803       tree dest = CALL_EXPR_ARG (exp, 0);
3804       tree src = CALL_EXPR_ARG (exp, 1);
3805       tree len = CALL_EXPR_ARG (exp, 2);
3806       tree slen = c_strlen (src, 1);
3807
3808       /* We must be passed a constant len and src parameter.  */
3809       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3810         return NULL_RTX;
3811
3812       slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3813
3814       /* We're required to pad with trailing zeros if the requested
3815          len is greater than strlen(s2)+1.  In that case try to
3816          use store_by_pieces, if it fails, punt.  */
3817       if (tree_int_cst_lt (slen, len))
3818         {
3819           unsigned int dest_align
3820             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3821           const char *p = c_getstr (src);
3822           rtx dest_mem;
3823
3824           if (!p || dest_align == 0 || !host_integerp (len, 1)
3825               || !can_store_by_pieces (tree_low_cst (len, 1),
3826                                        builtin_strncpy_read_str,
3827                                        CONST_CAST (char *, p),
3828                                        dest_align, false))
3829             return NULL_RTX;
3830
3831           dest_mem = get_memory_rtx (dest, len);
3832           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3833                            builtin_strncpy_read_str,
3834                            CONST_CAST (char *, p), dest_align, false, 0);
3835           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3836           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3837           return dest_mem;
3838         }
3839     }
3840   return NULL_RTX;
3841 }
3842
3843 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3844    bytes from constant string DATA + OFFSET and return it as target
3845    constant.  */
3846
3847 rtx
3848 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3849                          enum machine_mode mode)
3850 {
3851   const char *c = (const char *) data;
3852   char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3853
3854   memset (p, *c, GET_MODE_SIZE (mode));
3855
3856   return c_readstr (p, mode);
3857 }
3858
3859 /* Callback routine for store_by_pieces.  Return the RTL of a register
3860    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3861    char value given in the RTL register data.  For example, if mode is
3862    4 bytes wide, return the RTL for 0x01010101*data.  */
3863
3864 static rtx
3865 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3866                         enum machine_mode mode)
3867 {
3868   rtx target, coeff;
3869   size_t size;
3870   char *p;
3871
3872   size = GET_MODE_SIZE (mode);
3873   if (size == 1)
3874     return (rtx) data;
3875
3876   p = XALLOCAVEC (char, size);
3877   memset (p, 1, size);
3878   coeff = c_readstr (p, mode);
3879
3880   target = convert_to_mode (mode, (rtx) data, 1);
3881   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3882   return force_reg (mode, target);
3883 }
3884
3885 /* Expand expression EXP, which is a call to the memset builtin.  Return
3886    NULL_RTX if we failed the caller should emit a normal call, otherwise
3887    try to get the result in TARGET, if convenient (and in mode MODE if that's
3888    convenient).  */
3889
3890 static rtx
3891 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3892 {
3893   if (!validate_arglist (exp,
3894                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3895     return NULL_RTX;
3896   else
3897     {
3898       tree dest = CALL_EXPR_ARG (exp, 0);
3899       tree val = CALL_EXPR_ARG (exp, 1);
3900       tree len = CALL_EXPR_ARG (exp, 2);
3901       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3902     }
3903 }
3904
3905 /* Helper function to do the actual work for expand_builtin_memset.  The
3906    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3907    so that this can also be called without constructing an actual CALL_EXPR.
3908    The other arguments and return value are the same as for
3909    expand_builtin_memset.  */
3910
3911 static rtx
3912 expand_builtin_memset_args (tree dest, tree val, tree len,
3913                             rtx target, enum machine_mode mode, tree orig_exp)
3914 {
3915   tree fndecl, fn;
3916   enum built_in_function fcode;
3917   char c;
3918   unsigned int dest_align;
3919   rtx dest_mem, dest_addr, len_rtx;
3920   HOST_WIDE_INT expected_size = -1;
3921   unsigned int expected_align = 0;
3922
3923   dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3924
3925   /* If DEST is not a pointer type, don't do this operation in-line.  */
3926   if (dest_align == 0)
3927     return NULL_RTX;
3928
3929   if (currently_expanding_gimple_stmt)
3930     stringop_block_profile (currently_expanding_gimple_stmt,
3931                             &expected_align, &expected_size);
3932
3933   if (expected_align < dest_align)
3934     expected_align = dest_align;
3935
3936   /* If the LEN parameter is zero, return DEST.  */
3937   if (integer_zerop (len))
3938     {
3939       /* Evaluate and ignore VAL in case it has side-effects.  */
3940       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3941       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3942     }
3943
3944   /* Stabilize the arguments in case we fail.  */
3945   dest = builtin_save_expr (dest);
3946   val = builtin_save_expr (val);
3947   len = builtin_save_expr (len);
3948
3949   len_rtx = expand_normal (len);
3950   dest_mem = get_memory_rtx (dest, len);
3951
3952   if (TREE_CODE (val) != INTEGER_CST)
3953     {
3954       rtx val_rtx;
3955
3956       val_rtx = expand_normal (val);
3957       val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3958                                  val_rtx, 0);
3959
3960       /* Assume that we can memset by pieces if we can store
3961        * the coefficients by pieces (in the required modes).
3962        * We can't pass builtin_memset_gen_str as that emits RTL.  */
3963       c = 1;
3964       if (host_integerp (len, 1)
3965           && can_store_by_pieces (tree_low_cst (len, 1),
3966                                   builtin_memset_read_str, &c, dest_align,
3967                                   true))
3968         {
3969           val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3970                                val_rtx);
3971           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3972                            builtin_memset_gen_str, val_rtx, dest_align,
3973                            true, 0);
3974         }
3975       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3976                                         dest_align, expected_align,
3977                                         expected_size))
3978         goto do_libcall;
3979
3980       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3981       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3982       return dest_mem;
3983     }
3984
3985   if (target_char_cast (val, &c))
3986     goto do_libcall;
3987
3988   if (c)
3989     {
3990       if (host_integerp (len, 1)
3991           && can_store_by_pieces (tree_low_cst (len, 1),
3992                                   builtin_memset_read_str, &c, dest_align,
3993                                   true))
3994         store_by_pieces (dest_mem, tree_low_cst (len, 1),
3995                          builtin_memset_read_str, &c, dest_align, true, 0);
3996       else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3997                                         dest_align, expected_align,
3998                                         expected_size))
3999         goto do_libcall;
4000
4001       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4002       dest_mem = convert_memory_address (ptr_mode, dest_mem);
4003       return dest_mem;
4004     }
4005
4006   set_mem_align (dest_mem, dest_align);
4007   dest_addr = clear_storage_hints (dest_mem, len_rtx,
4008                                    CALL_EXPR_TAILCALL (orig_exp)
4009                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
4010                                    expected_align, expected_size);
4011
4012   if (dest_addr == 0)
4013     {
4014       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4015       dest_addr = convert_memory_address (ptr_mode, dest_addr);
4016     }
4017
4018   return dest_addr;
4019
4020  do_libcall:
4021   fndecl = get_callee_fndecl (orig_exp);
4022   fcode = DECL_FUNCTION_CODE (fndecl);
4023   if (fcode == BUILT_IN_MEMSET)
4024     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
4025                                 dest, val, len);
4026   else if (fcode == BUILT_IN_BZERO)
4027     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
4028                                 dest, len);
4029   else
4030     gcc_unreachable ();
4031   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4032   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
4033   return expand_call (fn, target, target == const0_rtx);
4034 }
4035
4036 /* Expand expression EXP, which is a call to the bzero builtin.  Return
4037    NULL_RTX if we failed the caller should emit a normal call.  */
4038
4039 static rtx
4040 expand_builtin_bzero (tree exp)
4041 {
4042   tree dest, size;
4043   location_t loc = EXPR_LOCATION (exp);
4044
4045   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4046     return NULL_RTX;
4047
4048   dest = CALL_EXPR_ARG (exp, 0);
4049   size = CALL_EXPR_ARG (exp, 1);
4050
4051   /* New argument list transforming bzero(ptr x, int y) to
4052      memset(ptr x, int 0, size_t y).   This is done this way
4053      so that if it isn't expanded inline, we fallback to
4054      calling bzero instead of memset.  */
4055
4056   return expand_builtin_memset_args (dest, integer_zero_node,
4057                                      fold_convert_loc (loc, sizetype, size),
4058                                      const0_rtx, VOIDmode, exp);
4059 }
4060
4061 /* Expand expression EXP, which is a call to the memcmp built-in function.
4062    Return NULL_RTX if we failed and the
4063    caller should emit a normal call, otherwise try to get the result in
4064    TARGET, if convenient (and in mode MODE, if that's convenient).  */
4065
4066 static rtx
4067 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4068                        ATTRIBUTE_UNUSED enum machine_mode mode)
4069 {
4070   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4071
4072   if (!validate_arglist (exp,
4073                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4074     return NULL_RTX;
4075
4076 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4077   {
4078     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4079     rtx result;
4080     rtx insn;
4081     tree arg1 = CALL_EXPR_ARG (exp, 0);
4082     tree arg2 = CALL_EXPR_ARG (exp, 1);
4083     tree len = CALL_EXPR_ARG (exp, 2);
4084
4085     unsigned int arg1_align
4086       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4087     unsigned int arg2_align
4088       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4089     enum machine_mode insn_mode;
4090
4091 #ifdef HAVE_cmpmemsi
4092     if (HAVE_cmpmemsi)
4093       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
4094     else
4095 #endif
4096 #ifdef HAVE_cmpstrnsi
4097     if (HAVE_cmpstrnsi)
4098       insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4099     else
4100 #endif
4101       return NULL_RTX;
4102
4103     /* If we don't have POINTER_TYPE, call the function.  */
4104     if (arg1_align == 0 || arg2_align == 0)
4105       return NULL_RTX;
4106
4107     /* Make a place to write the result of the instruction.  */
4108     result = target;
4109     if (! (result != 0
4110            && REG_P (result) && GET_MODE (result) == insn_mode
4111            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4112       result = gen_reg_rtx (insn_mode);
4113
4114     arg1_rtx = get_memory_rtx (arg1, len);
4115     arg2_rtx = get_memory_rtx (arg2, len);
4116     arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
4117
4118     /* Set MEM_SIZE as appropriate.  */
4119     if (CONST_INT_P (arg3_rtx))
4120       {
4121         set_mem_size (arg1_rtx, arg3_rtx);
4122         set_mem_size (arg2_rtx, arg3_rtx);
4123       }
4124
4125 #ifdef HAVE_cmpmemsi
4126     if (HAVE_cmpmemsi)
4127       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4128                            GEN_INT (MIN (arg1_align, arg2_align)));
4129     else
4130 #endif
4131 #ifdef HAVE_cmpstrnsi
4132     if (HAVE_cmpstrnsi)
4133       insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4134                             GEN_INT (MIN (arg1_align, arg2_align)));
4135     else
4136 #endif
4137       gcc_unreachable ();
4138
4139     if (insn)
4140       emit_insn (insn);
4141     else
4142       emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
4143                                TYPE_MODE (integer_type_node), 3,
4144                                XEXP (arg1_rtx, 0), Pmode,
4145                                XEXP (arg2_rtx, 0), Pmode,
4146                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
4147                                                 TYPE_UNSIGNED (sizetype)),
4148                                TYPE_MODE (sizetype));
4149
4150     /* Return the value in the proper mode for this function.  */
4151     mode = TYPE_MODE (TREE_TYPE (exp));
4152     if (GET_MODE (result) == mode)
4153       return result;
4154     else if (target != 0)
4155       {
4156         convert_move (target, result, 0);
4157         return target;
4158       }
4159     else
4160       return convert_to_mode (mode, result, 0);
4161   }
4162 #endif
4163
4164   return NULL_RTX;
4165 }
4166
4167 /* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
4168    if we failed the caller should emit a normal call, otherwise try to get
4169    the result in TARGET, if convenient.  */
4170
4171 static rtx
4172 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
4173 {
4174   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4175     return NULL_RTX;
4176
4177 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4178   if (direct_optab_handler (cmpstr_optab, SImode) != CODE_FOR_nothing
4179       || direct_optab_handler (cmpstrn_optab, SImode) != CODE_FOR_nothing)
4180     {
4181       rtx arg1_rtx, arg2_rtx;
4182       rtx result, insn = NULL_RTX;
4183       tree fndecl, fn;
4184       tree arg1 = CALL_EXPR_ARG (exp, 0);
4185       tree arg2 = CALL_EXPR_ARG (exp, 1);
4186
4187       unsigned int arg1_align
4188         = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4189       unsigned int arg2_align
4190         = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4191
4192       /* If we don't have POINTER_TYPE, call the function.  */
4193       if (arg1_align == 0 || arg2_align == 0)
4194         return NULL_RTX;
4195
4196       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
4197       arg1 = builtin_save_expr (arg1);
4198       arg2 = builtin_save_expr (arg2);
4199
4200       arg1_rtx = get_memory_rtx (arg1, NULL);
4201       arg2_rtx = get_memory_rtx (arg2, NULL);
4202
4203 #ifdef HAVE_cmpstrsi
4204       /* Try to call cmpstrsi.  */
4205       if (HAVE_cmpstrsi)
4206         {
4207           enum machine_mode insn_mode
4208             = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4209
4210           /* Make a place to write the result of the instruction.  */
4211           result = target;
4212           if (! (result != 0
4213                  && REG_P (result) && GET_MODE (result) == insn_mode
4214                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4215             result = gen_reg_rtx (insn_mode);
4216
4217           insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4218                                GEN_INT (MIN (arg1_align, arg2_align)));
4219         }
4220 #endif
4221 #ifdef HAVE_cmpstrnsi
4222       /* Try to determine at least one length and call cmpstrnsi.  */
4223       if (!insn && HAVE_cmpstrnsi)
4224         {
4225           tree len;
4226           rtx arg3_rtx;
4227
4228           enum machine_mode insn_mode
4229             = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4230           tree len1 = c_strlen (arg1, 1);
4231           tree len2 = c_strlen (arg2, 1);
4232
4233           if (len1)
4234             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4235           if (len2)
4236             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4237
4238           /* If we don't have a constant length for the first, use the length
4239              of the second, if we know it.  We don't require a constant for
4240              this case; some cost analysis could be done if both are available
4241              but neither is constant.  For now, assume they're equally cheap,
4242              unless one has side effects.  If both strings have constant lengths,
4243              use the smaller.  */
4244
4245           if (!len1)
4246             len = len2;
4247           else if (!len2)
4248             len = len1;
4249           else if (TREE_SIDE_EFFECTS (len1))
4250             len = len2;
4251           else if (TREE_SIDE_EFFECTS (len2))
4252             len = len1;
4253           else if (TREE_CODE (len1) != INTEGER_CST)
4254             len = len2;
4255           else if (TREE_CODE (len2) != INTEGER_CST)
4256             len = len1;
4257           else if (tree_int_cst_lt (len1, len2))
4258             len = len1;
4259           else
4260             len = len2;
4261
4262           /* If both arguments have side effects, we cannot optimize.  */
4263           if (!len || TREE_SIDE_EFFECTS (len))
4264             goto do_libcall;
4265
4266           arg3_rtx = expand_normal (len);
4267
4268           /* Make a place to write the result of the instruction.  */
4269           result = target;
4270           if (! (result != 0
4271                  && REG_P (result) && GET_MODE (result) == insn_mode
4272                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4273             result = gen_reg_rtx (insn_mode);
4274
4275           insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4276                                 GEN_INT (MIN (arg1_align, arg2_align)));
4277         }
4278 #endif
4279
4280       if (insn)
4281         {
4282           enum machine_mode mode;
4283           emit_insn (insn);
4284
4285           /* Return the value in the proper mode for this function.  */
4286           mode = TYPE_MODE (TREE_TYPE (exp));
4287           if (GET_MODE (result) == mode)
4288             return result;
4289           if (target == 0)
4290             return convert_to_mode (mode, result, 0);
4291           convert_move (target, result, 0);
4292           return target;
4293         }
4294
4295       /* Expand the library call ourselves using a stabilized argument
4296          list to avoid re-evaluating the function's arguments twice.  */
4297 #ifdef HAVE_cmpstrnsi
4298     do_libcall:
4299 #endif
4300       fndecl = get_callee_fndecl (exp);
4301       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
4302       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4303       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4304       return expand_call (fn, target, target == const0_rtx);
4305     }
4306 #endif
4307   return NULL_RTX;
4308 }
4309
4310 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4311    NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4312    the result in TARGET, if convenient.  */
4313
4314 static rtx
4315 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4316                         ATTRIBUTE_UNUSED enum machine_mode mode)
4317 {
4318   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4319
4320   if (!validate_arglist (exp,
4321                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4322     return NULL_RTX;
4323
4324   /* If c_strlen can determine an expression for one of the string
4325      lengths, and it doesn't have side effects, then emit cmpstrnsi
4326      using length MIN(strlen(string)+1, arg3).  */
4327 #ifdef HAVE_cmpstrnsi
4328   if (HAVE_cmpstrnsi)
4329   {
4330     tree len, len1, len2;
4331     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4332     rtx result, insn;
4333     tree fndecl, fn;
4334     tree arg1 = CALL_EXPR_ARG (exp, 0);
4335     tree arg2 = CALL_EXPR_ARG (exp, 1);
4336     tree arg3 = CALL_EXPR_ARG (exp, 2);
4337
4338     unsigned int arg1_align
4339       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4340     unsigned int arg2_align
4341       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4342     enum machine_mode insn_mode
4343       = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4344
4345     len1 = c_strlen (arg1, 1);
4346     len2 = c_strlen (arg2, 1);
4347
4348     if (len1)
4349       len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
4350     if (len2)
4351       len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
4352
4353     /* If we don't have a constant length for the first, use the length
4354        of the second, if we know it.  We don't require a constant for
4355        this case; some cost analysis could be done if both are available
4356        but neither is constant.  For now, assume they're equally cheap,
4357        unless one has side effects.  If both strings have constant lengths,
4358        use the smaller.  */
4359
4360     if (!len1)
4361       len = len2;
4362     else if (!len2)
4363       len = len1;
4364     else if (TREE_SIDE_EFFECTS (len1))
4365       len = len2;
4366     else if (TREE_SIDE_EFFECTS (len2))
4367       len = len1;
4368     else if (TREE_CODE (len1) != INTEGER_CST)
4369       len = len2;
4370     else if (TREE_CODE (len2) != INTEGER_CST)
4371       len = len1;
4372     else if (tree_int_cst_lt (len1, len2))
4373       len = len1;
4374     else
4375       len = len2;
4376
4377     /* If both arguments have side effects, we cannot optimize.  */
4378     if (!len || TREE_SIDE_EFFECTS (len))
4379       return NULL_RTX;
4380
4381     /* The actual new length parameter is MIN(len,arg3).  */
4382     len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4383                        fold_convert_loc (loc, TREE_TYPE (len), arg3));
4384
4385     /* If we don't have POINTER_TYPE, call the function.  */
4386     if (arg1_align == 0 || arg2_align == 0)
4387       return NULL_RTX;
4388
4389     /* Make a place to write the result of the instruction.  */
4390     result = target;
4391     if (! (result != 0
4392            && REG_P (result) && GET_MODE (result) == insn_mode
4393            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4394       result = gen_reg_rtx (insn_mode);
4395
4396     /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
4397     arg1 = builtin_save_expr (arg1);
4398     arg2 = builtin_save_expr (arg2);
4399     len = builtin_save_expr (len);
4400
4401     arg1_rtx = get_memory_rtx (arg1, len);
4402     arg2_rtx = get_memory_rtx (arg2, len);
4403     arg3_rtx = expand_normal (len);
4404     insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4405                           GEN_INT (MIN (arg1_align, arg2_align)));
4406     if (insn)
4407       {
4408         emit_insn (insn);
4409
4410         /* Return the value in the proper mode for this function.  */
4411         mode = TYPE_MODE (TREE_TYPE (exp));
4412         if (GET_MODE (result) == mode)
4413           return result;
4414         if (target == 0)
4415           return convert_to_mode (mode, result, 0);
4416         convert_move (target, result, 0);
4417         return target;
4418       }
4419
4420     /* Expand the library call ourselves using a stabilized argument
4421        list to avoid re-evaluating the function's arguments twice.  */
4422     fndecl = get_callee_fndecl (exp);
4423     fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
4424                                 arg1, arg2, len);
4425     gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4426     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4427     return expand_call (fn, target, target == const0_rtx);
4428   }
4429 #endif
4430   return NULL_RTX;
4431 }
4432
4433 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4434    if that's convenient.  */
4435
4436 rtx
4437 expand_builtin_saveregs (void)
4438 {
4439   rtx val, seq;
4440
4441   /* Don't do __builtin_saveregs more than once in a function.
4442      Save the result of the first call and reuse it.  */
4443   if (saveregs_value != 0)
4444     return saveregs_value;
4445
4446   /* When this function is called, it means that registers must be
4447      saved on entry to this function.  So we migrate the call to the
4448      first insn of this function.  */
4449
4450   start_sequence ();
4451
4452   /* Do whatever the machine needs done in this case.  */
4453   val = targetm.calls.expand_builtin_saveregs ();
4454
4455   seq = get_insns ();
4456   end_sequence ();
4457
4458   saveregs_value = val;
4459
4460   /* Put the insns after the NOTE that starts the function.  If this
4461      is inside a start_sequence, make the outer-level insn chain current, so
4462      the code is placed at the start of the function.  */
4463   push_topmost_sequence ();
4464   emit_insn_after (seq, entry_of_function ());
4465   pop_topmost_sequence ();
4466
4467   return val;
4468 }
4469
4470 /* Expand a call to __builtin_next_arg.  */
4471
4472 static rtx
4473 expand_builtin_next_arg (void)
4474 {
4475   /* Checking arguments is already done in fold_builtin_next_arg
4476      that must be called before this function.  */
4477   return expand_binop (ptr_mode, add_optab,
4478                        crtl->args.internal_arg_pointer,
4479                        crtl->args.arg_offset_rtx,
4480                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
4481 }
4482
4483 /* Make it easier for the backends by protecting the valist argument
4484    from multiple evaluations.  */
4485
4486 static tree
4487 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4488 {
4489   tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4490
4491   /* The current way of determining the type of valist is completely
4492      bogus.  We should have the information on the va builtin instead.  */
4493   if (!vatype)
4494     vatype = targetm.fn_abi_va_list (cfun->decl);
4495
4496   if (TREE_CODE (vatype) == ARRAY_TYPE)
4497     {
4498       if (TREE_SIDE_EFFECTS (valist))
4499         valist = save_expr (valist);
4500
4501       /* For this case, the backends will be expecting a pointer to
4502          vatype, but it's possible we've actually been given an array
4503          (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4504          So fix it.  */
4505       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4506         {
4507           tree p1 = build_pointer_type (TREE_TYPE (vatype));
4508           valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4509         }
4510     }
4511   else
4512     {
4513       tree pt = build_pointer_type (vatype);
4514
4515       if (! needs_lvalue)
4516         {
4517           if (! TREE_SIDE_EFFECTS (valist))
4518             return valist;
4519
4520           valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4521           TREE_SIDE_EFFECTS (valist) = 1;
4522         }
4523
4524       if (TREE_SIDE_EFFECTS (valist))
4525         valist = save_expr (valist);
4526       valist = fold_build2_loc (loc, MEM_REF,
4527                                 vatype, valist, build_int_cst (pt, 0));
4528     }
4529
4530   return valist;
4531 }
4532
4533 /* The "standard" definition of va_list is void*.  */
4534
4535 tree
4536 std_build_builtin_va_list (void)
4537 {
4538   return ptr_type_node;
4539 }
4540
4541 /* The "standard" abi va_list is va_list_type_node.  */
4542
4543 tree
4544 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4545 {
4546   return va_list_type_node;
4547 }
4548
4549 /* The "standard" type of va_list is va_list_type_node.  */
4550
4551 tree
4552 std_canonical_va_list_type (tree type)
4553 {
4554   tree wtype, htype;
4555
4556   if (INDIRECT_REF_P (type))
4557     type = TREE_TYPE (type);
4558   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4559     type = TREE_TYPE (type);
4560   wtype = va_list_type_node;
4561   htype = type;
4562   /* Treat structure va_list types.  */
4563   if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4564     htype = TREE_TYPE (htype);
4565   else if (TREE_CODE (wtype) == ARRAY_TYPE)
4566     {
4567       /* If va_list is an array type, the argument may have decayed
4568          to a pointer type, e.g. by being passed to another function.
4569          In that case, unwrap both types so that we can compare the
4570          underlying records.  */
4571       if (TREE_CODE (htype) == ARRAY_TYPE
4572           || POINTER_TYPE_P (htype))
4573         {
4574           wtype = TREE_TYPE (wtype);
4575           htype = TREE_TYPE (htype);
4576         }
4577     }
4578   if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4579     return va_list_type_node;
4580
4581   return NULL_TREE;
4582 }
4583
4584 /* The "standard" implementation of va_start: just assign `nextarg' to
4585    the variable.  */
4586
4587 void
4588 std_expand_builtin_va_start (tree valist, rtx nextarg)
4589 {
4590   rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4591   convert_move (va_r, nextarg, 0);
4592 }
4593
4594 /* Expand EXP, a call to __builtin_va_start.  */
4595
4596 static rtx
4597 expand_builtin_va_start (tree exp)
4598 {
4599   rtx nextarg;
4600   tree valist;
4601   location_t loc = EXPR_LOCATION (exp);
4602
4603   if (call_expr_nargs (exp) < 2)
4604     {
4605       error_at (loc, "too few arguments to function %<va_start%>");
4606       return const0_rtx;
4607     }
4608
4609   if (fold_builtin_next_arg (exp, true))
4610     return const0_rtx;
4611
4612   nextarg = expand_builtin_next_arg ();
4613   valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4614
4615   if (targetm.expand_builtin_va_start)
4616     targetm.expand_builtin_va_start (valist, nextarg);
4617   else
4618     std_expand_builtin_va_start (valist, nextarg);
4619
4620   return const0_rtx;
4621 }
4622
4623 /* The "standard" implementation of va_arg: read the value from the
4624    current (padded) address and increment by the (padded) size.  */
4625
4626 tree
4627 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4628                           gimple_seq *post_p)
4629 {
4630   tree addr, t, type_size, rounded_size, valist_tmp;
4631   unsigned HOST_WIDE_INT align, boundary;
4632   bool indirect;
4633
4634 #ifdef ARGS_GROW_DOWNWARD
4635   /* All of the alignment and movement below is for args-grow-up machines.
4636      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4637      implement their own specialized gimplify_va_arg_expr routines.  */
4638   gcc_unreachable ();
4639 #endif
4640
4641   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4642   if (indirect)
4643     type = build_pointer_type (type);
4644
4645   align = PARM_BOUNDARY / BITS_PER_UNIT;
4646   boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
4647
4648   /* When we align parameter on stack for caller, if the parameter
4649      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4650      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
4651      here with caller.  */
4652   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4653     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4654
4655   boundary /= BITS_PER_UNIT;
4656
4657   /* Hoist the valist value into a temporary for the moment.  */
4658   valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4659
4660   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
4661      requires greater alignment, we must perform dynamic alignment.  */
4662   if (boundary > align
4663       && !integer_zerop (TYPE_SIZE (type)))
4664     {
4665       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4666                   fold_build2 (POINTER_PLUS_EXPR,
4667                                TREE_TYPE (valist),
4668                                valist_tmp, size_int (boundary - 1)));
4669       gimplify_and_add (t, pre_p);
4670
4671       t = fold_convert (sizetype, valist_tmp);
4672       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4673                   fold_convert (TREE_TYPE (valist),
4674                                 fold_build2 (BIT_AND_EXPR, sizetype, t,
4675                                              size_int (-boundary))));
4676       gimplify_and_add (t, pre_p);
4677     }
4678   else
4679     boundary = align;
4680
4681   /* If the actual alignment is less than the alignment of the type,
4682      adjust the type accordingly so that we don't assume strict alignment
4683      when dereferencing the pointer.  */
4684   boundary *= BITS_PER_UNIT;
4685   if (boundary < TYPE_ALIGN (type))
4686     {
4687       type = build_variant_type_copy (type);
4688       TYPE_ALIGN (type) = boundary;
4689     }
4690
4691   /* Compute the rounded size of the type.  */
4692   type_size = size_in_bytes (type);
4693   rounded_size = round_up (type_size, align);
4694
4695   /* Reduce rounded_size so it's sharable with the postqueue.  */
4696   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4697
4698   /* Get AP.  */
4699   addr = valist_tmp;
4700   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4701     {
4702       /* Small args are padded downward.  */
4703       t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4704                        rounded_size, size_int (align));
4705       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4706                        size_binop (MINUS_EXPR, rounded_size, type_size));
4707       addr = fold_build2 (POINTER_PLUS_EXPR,
4708                           TREE_TYPE (addr), addr, t);
4709     }
4710
4711   /* Compute new value for AP.  */
4712   t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist), valist_tmp, rounded_size);
4713   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4714   gimplify_and_add (t, pre_p);
4715
4716   addr = fold_convert (build_pointer_type (type), addr);
4717
4718   if (indirect)
4719     addr = build_va_arg_indirect_ref (addr);
4720
4721   return build_va_arg_indirect_ref (addr);
4722 }
4723
4724 /* Build an indirect-ref expression over the given TREE, which represents a
4725    piece of a va_arg() expansion.  */
4726 tree
4727 build_va_arg_indirect_ref (tree addr)
4728 {
4729   addr = build_fold_indirect_ref_loc (EXPR_LOCATION (addr), addr);
4730
4731   if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF.  */
4732     mf_mark (addr);
4733
4734   return addr;
4735 }
4736
4737 /* Return a dummy expression of type TYPE in order to keep going after an
4738    error.  */
4739
4740 static tree
4741 dummy_object (tree type)
4742 {
4743   tree t = build_int_cst (build_pointer_type (type), 0);
4744   return build1 (INDIRECT_REF, type, t);
4745 }
4746
4747 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4748    builtin function, but a very special sort of operator.  */
4749
4750 enum gimplify_status
4751 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4752 {
4753   tree promoted_type, have_va_type;
4754   tree valist = TREE_OPERAND (*expr_p, 0);
4755   tree type = TREE_TYPE (*expr_p);
4756   tree t;
4757   location_t loc = EXPR_LOCATION (*expr_p);
4758
4759   /* Verify that valist is of the proper type.  */
4760   have_va_type = TREE_TYPE (valist);
4761   if (have_va_type == error_mark_node)
4762     return GS_ERROR;
4763   have_va_type = targetm.canonical_va_list_type (have_va_type);
4764
4765   if (have_va_type == NULL_TREE)
4766     {
4767       error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4768       return GS_ERROR;
4769     }
4770
4771   /* Generate a diagnostic for requesting data of a type that cannot
4772      be passed through `...' due to type promotion at the call site.  */
4773   if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4774            != type)
4775     {
4776       static bool gave_help;
4777       bool warned;
4778
4779       /* Unfortunately, this is merely undefined, rather than a constraint
4780          violation, so we cannot make this an error.  If this call is never
4781          executed, the program is still strictly conforming.  */
4782       warned = warning_at (loc, 0,
4783                            "%qT is promoted to %qT when passed through %<...%>",
4784                            type, promoted_type);
4785       if (!gave_help && warned)
4786         {
4787           gave_help = true;
4788           inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4789                   promoted_type, type);
4790         }
4791
4792       /* We can, however, treat "undefined" any way we please.
4793          Call abort to encourage the user to fix the program.  */
4794       if (warned)
4795         inform (loc, "if this code is reached, the program will abort");
4796       /* Before the abort, allow the evaluation of the va_list
4797          expression to exit or longjmp.  */
4798       gimplify_and_add (valist, pre_p);
4799       t = build_call_expr_loc (loc,
4800                                implicit_built_in_decls[BUILT_IN_TRAP], 0);
4801       gimplify_and_add (t, pre_p);
4802
4803       /* This is dead code, but go ahead and finish so that the
4804          mode of the result comes out right.  */
4805       *expr_p = dummy_object (type);
4806       return GS_ALL_DONE;
4807     }
4808   else
4809     {
4810       /* Make it easier for the backends by protecting the valist argument
4811          from multiple evaluations.  */
4812       if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4813         {
4814           /* For this case, the backends will be expecting a pointer to
4815              TREE_TYPE (abi), but it's possible we've
4816              actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4817              So fix it.  */
4818           if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4819             {
4820               tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4821               valist = fold_convert_loc (loc, p1,
4822                                          build_fold_addr_expr_loc (loc, valist));
4823             }
4824
4825           gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4826         }
4827       else
4828         gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4829
4830       if (!targetm.gimplify_va_arg_expr)
4831         /* FIXME: Once most targets are converted we should merely
4832            assert this is non-null.  */
4833         return GS_ALL_DONE;
4834
4835       *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4836       return GS_OK;
4837     }
4838 }
4839
4840 /* Expand EXP, a call to __builtin_va_end.  */
4841
4842 static rtx
4843 expand_builtin_va_end (tree exp)
4844 {
4845   tree valist = CALL_EXPR_ARG (exp, 0);
4846
4847   /* Evaluate for side effects, if needed.  I hate macros that don't
4848      do that.  */
4849   if (TREE_SIDE_EFFECTS (valist))
4850     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4851
4852   return const0_rtx;
4853 }
4854
4855 /* Expand EXP, a call to __builtin_va_copy.  We do this as a
4856    builtin rather than just as an assignment in stdarg.h because of the
4857    nastiness of array-type va_list types.  */
4858
4859 static rtx
4860 expand_builtin_va_copy (tree exp)
4861 {
4862   tree dst, src, t;
4863   location_t loc = EXPR_LOCATION (exp);
4864
4865   dst = CALL_EXPR_ARG (exp, 0);
4866   src = CALL_EXPR_ARG (exp, 1);
4867
4868   dst = stabilize_va_list_loc (loc, dst, 1);
4869   src = stabilize_va_list_loc (loc, src, 0);
4870
4871   gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4872
4873   if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4874     {
4875       t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4876       TREE_SIDE_EFFECTS (t) = 1;
4877       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4878     }
4879   else
4880     {
4881       rtx dstb, srcb, size;
4882
4883       /* Evaluate to pointers.  */
4884       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4885       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4886       size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4887                   NULL_RTX, VOIDmode, EXPAND_NORMAL);
4888
4889       dstb = convert_memory_address (Pmode, dstb);
4890       srcb = convert_memory_address (Pmode, srcb);
4891
4892       /* "Dereference" to BLKmode memories.  */
4893       dstb = gen_rtx_MEM (BLKmode, dstb);
4894       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4895       set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4896       srcb = gen_rtx_MEM (BLKmode, srcb);
4897       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4898       set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4899
4900       /* Copy.  */
4901       emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4902     }
4903
4904   return const0_rtx;
4905 }
4906
4907 /* Expand a call to one of the builtin functions __builtin_frame_address or
4908    __builtin_return_address.  */
4909
4910 static rtx
4911 expand_builtin_frame_address (tree fndecl, tree exp)
4912 {
4913   /* The argument must be a nonnegative integer constant.
4914      It counts the number of frames to scan up the stack.
4915      The value is the return address saved in that frame.  */
4916   if (call_expr_nargs (exp) == 0)
4917     /* Warning about missing arg was already issued.  */
4918     return const0_rtx;
4919   else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4920     {
4921       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4922         error ("invalid argument to %<__builtin_frame_address%>");
4923       else
4924         error ("invalid argument to %<__builtin_return_address%>");
4925       return const0_rtx;
4926     }
4927   else
4928     {
4929       rtx tem
4930         = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4931                                       tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4932
4933       /* Some ports cannot access arbitrary stack frames.  */
4934       if (tem == NULL)
4935         {
4936           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4937             warning (0, "unsupported argument to %<__builtin_frame_address%>");
4938           else
4939             warning (0, "unsupported argument to %<__builtin_return_address%>");
4940           return const0_rtx;
4941         }
4942
4943       /* For __builtin_frame_address, return what we've got.  */
4944       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4945         return tem;
4946
4947       if (!REG_P (tem)
4948           && ! CONSTANT_P (tem))
4949         tem = copy_to_mode_reg (Pmode, tem);
4950       return tem;
4951     }
4952 }
4953
4954 /* Expand EXP, a call to the alloca builtin.  Return NULL_RTX if we
4955    failed and the caller should emit a normal call, otherwise try to
4956    get the result in TARGET, if convenient.  CANNOT_ACCUMULATE is the
4957    same as for allocate_dynamic_stack_space.  */
4958
4959 static rtx
4960 expand_builtin_alloca (tree exp, rtx target, bool cannot_accumulate)
4961 {
4962   rtx op0;
4963   rtx result;
4964
4965   /* Emit normal call if marked not-inlineable.  */
4966   if (CALL_CANNOT_INLINE_P (exp))
4967     return NULL_RTX;
4968
4969   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4970     return NULL_RTX;
4971
4972   /* Compute the argument.  */
4973   op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4974
4975   /* Allocate the desired space.  */
4976   result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT,
4977                                          cannot_accumulate);
4978   result = convert_memory_address (ptr_mode, result);
4979
4980   return result;
4981 }
4982
4983 /* Expand a call to a bswap builtin with argument ARG0.  MODE
4984    is the mode to expand with.  */
4985
4986 static rtx
4987 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
4988 {
4989   enum machine_mode mode;
4990   tree arg;
4991   rtx op0;
4992
4993   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4994     return NULL_RTX;
4995
4996   arg = CALL_EXPR_ARG (exp, 0);
4997   mode = TYPE_MODE (TREE_TYPE (arg));
4998   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4999
5000   target = expand_unop (mode, bswap_optab, op0, target, 1);
5001
5002   gcc_assert (target);
5003
5004   return convert_to_mode (mode, target, 0);
5005 }
5006
5007 /* Expand a call to a unary builtin in EXP.
5008    Return NULL_RTX if a normal call should be emitted rather than expanding the
5009    function in-line.  If convenient, the result should be placed in TARGET.
5010    SUBTARGET may be used as the target for computing one of EXP's operands.  */
5011
5012 static rtx
5013 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
5014                      rtx subtarget, optab op_optab)
5015 {
5016   rtx op0;
5017
5018   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5019     return NULL_RTX;
5020
5021   /* Compute the argument.  */
5022   op0 = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
5023                      VOIDmode, EXPAND_NORMAL);
5024   /* Compute op, into TARGET if possible.
5025      Set TARGET to wherever the result comes back.  */
5026   target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
5027                         op_optab, op0, target, 1);
5028   gcc_assert (target);
5029
5030   return convert_to_mode (target_mode, target, 0);
5031 }
5032
5033 /* Expand a call to __builtin_expect.  We just return our argument
5034    as the builtin_expect semantic should've been already executed by
5035    tree branch prediction pass. */
5036
5037 static rtx
5038 expand_builtin_expect (tree exp, rtx target)
5039 {
5040   tree arg;
5041
5042   if (call_expr_nargs (exp) < 2)
5043     return const0_rtx;
5044   arg = CALL_EXPR_ARG (exp, 0);
5045
5046   target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5047   /* When guessing was done, the hints should be already stripped away.  */
5048   gcc_assert (!flag_guess_branch_prob
5049               || optimize == 0 || seen_error ());
5050   return target;
5051 }
5052
5053 void
5054 expand_builtin_trap (void)
5055 {
5056 #ifdef HAVE_trap
5057   if (HAVE_trap)
5058     emit_insn (gen_trap ());
5059   else
5060 #endif
5061     emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
5062   emit_barrier ();
5063 }
5064
5065 /* Expand a call to __builtin_unreachable.  We do nothing except emit
5066    a barrier saying that control flow will not pass here.
5067
5068    It is the responsibility of the program being compiled to ensure
5069    that control flow does never reach __builtin_unreachable.  */
5070 static void
5071 expand_builtin_unreachable (void)
5072 {
5073   emit_barrier ();
5074 }
5075
5076 /* Expand EXP, a call to fabs, fabsf or fabsl.
5077    Return NULL_RTX if a normal call should be emitted rather than expanding
5078    the function inline.  If convenient, the result should be placed
5079    in TARGET.  SUBTARGET may be used as the target for computing
5080    the operand.  */
5081
5082 static rtx
5083 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
5084 {
5085   enum machine_mode mode;
5086   tree arg;
5087   rtx op0;
5088
5089   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5090     return NULL_RTX;
5091
5092   arg = CALL_EXPR_ARG (exp, 0);
5093   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
5094   mode = TYPE_MODE (TREE_TYPE (arg));
5095   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5096   return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
5097 }
5098
5099 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5100    Return NULL is a normal call should be emitted rather than expanding the
5101    function inline.  If convenient, the result should be placed in TARGET.
5102    SUBTARGET may be used as the target for computing the operand.  */
5103
5104 static rtx
5105 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
5106 {
5107   rtx op0, op1;
5108   tree arg;
5109
5110   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
5111     return NULL_RTX;
5112
5113   arg = CALL_EXPR_ARG (exp, 0);
5114   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5115
5116   arg = CALL_EXPR_ARG (exp, 1);
5117   op1 = expand_normal (arg);
5118
5119   return expand_copysign (op0, op1, target);
5120 }
5121
5122 /* Create a new constant string literal and return a char* pointer to it.
5123    The STRING_CST value is the LEN characters at STR.  */
5124 tree
5125 build_string_literal (int len, const char *str)
5126 {
5127   tree t, elem, index, type;
5128
5129   t = build_string (len, str);
5130   elem = build_type_variant (char_type_node, 1, 0);
5131   index = build_index_type (size_int (len - 1));
5132   type = build_array_type (elem, index);
5133   TREE_TYPE (t) = type;
5134   TREE_CONSTANT (t) = 1;
5135   TREE_READONLY (t) = 1;
5136   TREE_STATIC (t) = 1;
5137
5138   type = build_pointer_type (elem);
5139   t = build1 (ADDR_EXPR, type,
5140               build4 (ARRAY_REF, elem,
5141                       t, integer_zero_node, NULL_TREE, NULL_TREE));
5142   return t;
5143 }
5144
5145 /* Expand a call to either the entry or exit function profiler.  */
5146
5147 static rtx
5148 expand_builtin_profile_func (bool exitp)
5149 {
5150   rtx this_rtx, which;
5151
5152   this_rtx = DECL_RTL (current_function_decl);
5153   gcc_assert (MEM_P (this_rtx));
5154   this_rtx = XEXP (this_rtx, 0);
5155
5156   if (exitp)
5157     which = profile_function_exit_libfunc;
5158   else
5159     which = profile_function_entry_libfunc;
5160
5161   emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this_rtx, Pmode,
5162                      expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5163                                                  0),
5164                      Pmode);
5165
5166   return const0_rtx;
5167 }
5168
5169 /* Expand a call to __builtin___clear_cache.  */
5170
5171 static rtx
5172 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
5173 {
5174 #ifndef HAVE_clear_cache
5175 #ifdef CLEAR_INSN_CACHE
5176   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5177      does something.  Just do the default expansion to a call to
5178      __clear_cache().  */
5179   return NULL_RTX;
5180 #else
5181   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5182      does nothing.  There is no need to call it.  Do nothing.  */
5183   return const0_rtx;
5184 #endif /* CLEAR_INSN_CACHE */
5185 #else
5186   /* We have a "clear_cache" insn, and it will handle everything.  */
5187   tree begin, end;
5188   rtx begin_rtx, end_rtx;
5189   enum insn_code icode;
5190
5191   /* We must not expand to a library call.  If we did, any
5192      fallback library function in libgcc that might contain a call to
5193      __builtin___clear_cache() would recurse infinitely.  */
5194   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5195     {
5196       error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5197       return const0_rtx;
5198     }
5199
5200   if (HAVE_clear_cache)
5201     {
5202       icode = CODE_FOR_clear_cache;
5203
5204       begin = CALL_EXPR_ARG (exp, 0);
5205       begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
5206       begin_rtx = convert_memory_address (Pmode, begin_rtx);
5207       if (!insn_data[icode].operand[0].predicate (begin_rtx, Pmode))
5208         begin_rtx = copy_to_mode_reg (Pmode, begin_rtx);
5209
5210       end = CALL_EXPR_ARG (exp, 1);
5211       end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
5212       end_rtx = convert_memory_address (Pmode, end_rtx);
5213       if (!insn_data[icode].operand[1].predicate (end_rtx, Pmode))
5214         end_rtx = copy_to_mode_reg (Pmode, end_rtx);
5215
5216       emit_insn (gen_clear_cache (begin_rtx, end_rtx));
5217     }
5218   return const0_rtx;
5219 #endif /* HAVE_clear_cache */
5220 }
5221
5222 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT.  */
5223
5224 static rtx
5225 round_trampoline_addr (rtx tramp)
5226 {
5227   rtx temp, addend, mask;
5228
5229   /* If we don't need too much alignment, we'll have been guaranteed
5230      proper alignment by get_trampoline_type.  */
5231   if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5232     return tramp;
5233
5234   /* Round address up to desired boundary.  */
5235   temp = gen_reg_rtx (Pmode);
5236   addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5237   mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5238
5239   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5240                                temp, 0, OPTAB_LIB_WIDEN);
5241   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5242                                temp, 0, OPTAB_LIB_WIDEN);
5243
5244   return tramp;
5245 }
5246
5247 static rtx
5248 expand_builtin_init_trampoline (tree exp)
5249 {
5250   tree t_tramp, t_func, t_chain;
5251   rtx m_tramp, r_tramp, r_chain, tmp;
5252
5253   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5254                          POINTER_TYPE, VOID_TYPE))
5255     return NULL_RTX;
5256
5257   t_tramp = CALL_EXPR_ARG (exp, 0);
5258   t_func = CALL_EXPR_ARG (exp, 1);
5259   t_chain = CALL_EXPR_ARG (exp, 2);
5260
5261   r_tramp = expand_normal (t_tramp);
5262   m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
5263   MEM_NOTRAP_P (m_tramp) = 1;
5264
5265   /* The TRAMP argument should be the address of a field within the
5266      local function's FRAME decl.  Let's see if we can fill in the
5267      to fill in the MEM_ATTRs for this memory.  */
5268   if (TREE_CODE (t_tramp) == ADDR_EXPR)
5269     set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
5270                                      true, 0);
5271
5272   tmp = round_trampoline_addr (r_tramp);
5273   if (tmp != r_tramp)
5274     {
5275       m_tramp = change_address (m_tramp, BLKmode, tmp);
5276       set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
5277       set_mem_size (m_tramp, GEN_INT (TRAMPOLINE_SIZE));
5278     }
5279
5280   /* The FUNC argument should be the address of the nested function.
5281      Extract the actual function decl to pass to the hook.  */
5282   gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
5283   t_func = TREE_OPERAND (t_func, 0);
5284   gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
5285
5286   r_chain = expand_normal (t_chain);
5287
5288   /* Generate insns to initialize the trampoline.  */
5289   targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
5290
5291   trampolines_created = 1;
5292
5293   warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
5294               "trampoline generated for nested function %qD", t_func);
5295
5296   return const0_rtx;
5297 }
5298
5299 static rtx
5300 expand_builtin_adjust_trampoline (tree exp)
5301 {
5302   rtx tramp;
5303
5304   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5305     return NULL_RTX;
5306
5307   tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5308   tramp = round_trampoline_addr (tramp);
5309   if (targetm.calls.trampoline_adjust_address)
5310     tramp = targetm.calls.trampoline_adjust_address (tramp);
5311
5312   return tramp;
5313 }
5314
5315 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5316    function.  The function first checks whether the back end provides
5317    an insn to implement signbit for the respective mode.  If not, it
5318    checks whether the floating point format of the value is such that
5319    the sign bit can be extracted.  If that is not the case, the
5320    function returns NULL_RTX to indicate that a normal call should be
5321    emitted rather than expanding the function in-line.  EXP is the
5322    expression that is a call to the builtin function; if convenient,
5323    the result should be placed in TARGET.  */
5324 static rtx
5325 expand_builtin_signbit (tree exp, rtx target)
5326 {
5327   const struct real_format *fmt;
5328   enum machine_mode fmode, imode, rmode;
5329   tree arg;
5330   int word, bitpos;
5331   enum insn_code icode;
5332   rtx temp;
5333   location_t loc = EXPR_LOCATION (exp);
5334
5335   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5336     return NULL_RTX;
5337
5338   arg = CALL_EXPR_ARG (exp, 0);
5339   fmode = TYPE_MODE (TREE_TYPE (arg));
5340   rmode = TYPE_MODE (TREE_TYPE (exp));
5341   fmt = REAL_MODE_FORMAT (fmode);
5342
5343   arg = builtin_save_expr (arg);
5344
5345   /* Expand the argument yielding a RTX expression. */
5346   temp = expand_normal (arg);
5347
5348   /* Check if the back end provides an insn that handles signbit for the
5349      argument's mode. */
5350   icode = optab_handler (signbit_optab, fmode);
5351   if (icode != CODE_FOR_nothing)
5352     {
5353       rtx last = get_last_insn ();
5354       target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5355       if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
5356         return target;
5357       delete_insns_since (last);
5358     }
5359
5360   /* For floating point formats without a sign bit, implement signbit
5361      as "ARG < 0.0".  */
5362   bitpos = fmt->signbit_ro;
5363   if (bitpos < 0)
5364   {
5365     /* But we can't do this if the format supports signed zero.  */
5366     if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5367       return NULL_RTX;
5368
5369     arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5370                        build_real (TREE_TYPE (arg), dconst0));
5371     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5372   }
5373
5374   if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5375     {
5376       imode = int_mode_for_mode (fmode);
5377       if (imode == BLKmode)
5378         return NULL_RTX;
5379       temp = gen_lowpart (imode, temp);
5380     }
5381   else
5382     {
5383       imode = word_mode;
5384       /* Handle targets with different FP word orders.  */
5385       if (FLOAT_WORDS_BIG_ENDIAN)
5386         word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5387       else
5388         word = bitpos / BITS_PER_WORD;
5389       temp = operand_subword_force (temp, word, fmode);
5390       bitpos = bitpos % BITS_PER_WORD;
5391     }
5392
5393   /* Force the intermediate word_mode (or narrower) result into a
5394      register.  This avoids attempting to create paradoxical SUBREGs
5395      of floating point modes below.  */
5396   temp = force_reg (imode, temp);
5397
5398   /* If the bitpos is within the "result mode" lowpart, the operation
5399      can be implement with a single bitwise AND.  Otherwise, we need
5400      a right shift and an AND.  */
5401
5402   if (bitpos < GET_MODE_BITSIZE (rmode))
5403     {
5404       double_int mask = double_int_setbit (double_int_zero, bitpos);
5405
5406       if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5407         temp = gen_lowpart (rmode, temp);
5408       temp = expand_binop (rmode, and_optab, temp,
5409                            immed_double_int_const (mask, rmode),
5410                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5411     }
5412   else
5413     {
5414       /* Perform a logical right shift to place the signbit in the least
5415          significant bit, then truncate the result to the desired mode
5416          and mask just this bit.  */
5417       temp = expand_shift (RSHIFT_EXPR, imode, temp,
5418                            build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5419       temp = gen_lowpart (rmode, temp);
5420       temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5421                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5422     }
5423
5424   return temp;
5425 }
5426
5427 /* Expand fork or exec calls.  TARGET is the desired target of the
5428    call.  EXP is the call. FN is the
5429    identificator of the actual function.  IGNORE is nonzero if the
5430    value is to be ignored.  */
5431
5432 static rtx
5433 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5434 {
5435   tree id, decl;
5436   tree call;
5437
5438   /* If we are not profiling, just call the function.  */
5439   if (!profile_arc_flag)
5440     return NULL_RTX;
5441
5442   /* Otherwise call the wrapper.  This should be equivalent for the rest of
5443      compiler, so the code does not diverge, and the wrapper may run the
5444      code necessary for keeping the profiling sane.  */
5445
5446   switch (DECL_FUNCTION_CODE (fn))
5447     {
5448     case BUILT_IN_FORK:
5449       id = get_identifier ("__gcov_fork");
5450       break;
5451
5452     case BUILT_IN_EXECL:
5453       id = get_identifier ("__gcov_execl");
5454       break;
5455
5456     case BUILT_IN_EXECV:
5457       id = get_identifier ("__gcov_execv");
5458       break;
5459
5460     case BUILT_IN_EXECLP:
5461       id = get_identifier ("__gcov_execlp");
5462       break;
5463
5464     case BUILT_IN_EXECLE:
5465       id = get_identifier ("__gcov_execle");
5466       break;
5467
5468     case BUILT_IN_EXECVP:
5469       id = get_identifier ("__gcov_execvp");
5470       break;
5471
5472     case BUILT_IN_EXECVE:
5473       id = get_identifier ("__gcov_execve");
5474       break;
5475
5476     default:
5477       gcc_unreachable ();
5478     }
5479
5480   decl = build_decl (DECL_SOURCE_LOCATION (fn),
5481                      FUNCTION_DECL, id, TREE_TYPE (fn));
5482   DECL_EXTERNAL (decl) = 1;
5483   TREE_PUBLIC (decl) = 1;
5484   DECL_ARTIFICIAL (decl) = 1;
5485   TREE_NOTHROW (decl) = 1;
5486   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5487   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5488   call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5489   return expand_call (call, target, ignore);
5490  }
5491
5492
5493 \f
5494 /* Reconstitute a mode for a __sync intrinsic operation.  Since the type of
5495    the pointer in these functions is void*, the tree optimizers may remove
5496    casts.  The mode computed in expand_builtin isn't reliable either, due
5497    to __sync_bool_compare_and_swap.
5498
5499    FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5500    group of builtins.  This gives us log2 of the mode size.  */
5501
5502 static inline enum machine_mode
5503 get_builtin_sync_mode (int fcode_diff)
5504 {
5505   /* The size is not negotiable, so ask not to get BLKmode in return
5506      if the target indicates that a smaller size would be better.  */
5507   return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5508 }
5509
5510 /* Expand the memory expression LOC and return the appropriate memory operand
5511    for the builtin_sync operations.  */
5512
5513 static rtx
5514 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5515 {
5516   rtx addr, mem;
5517
5518   addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
5519   addr = convert_memory_address (Pmode, addr);
5520
5521   /* Note that we explicitly do not want any alias information for this
5522      memory, so that we kill all other live memories.  Otherwise we don't
5523      satisfy the full barrier semantics of the intrinsic.  */
5524   mem = validize_mem (gen_rtx_MEM (mode, addr));
5525
5526   /* The alignment needs to be at least according to that of the mode.  */
5527   set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
5528                            get_pointer_alignment (loc, BIGGEST_ALIGNMENT)));
5529   set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5530   MEM_VOLATILE_P (mem) = 1;
5531
5532   return mem;
5533 }
5534
5535 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5536    EXP is the CALL_EXPR.  CODE is the rtx code
5537    that corresponds to the arithmetic or logical operation from the name;
5538    an exception here is that NOT actually means NAND.  TARGET is an optional
5539    place for us to store the results; AFTER is true if this is the
5540    fetch_and_xxx form.  IGNORE is true if we don't actually care about
5541    the result of the operation at all.  */
5542
5543 static rtx
5544 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5545                                enum rtx_code code, bool after,
5546                                rtx target, bool ignore)
5547 {
5548   rtx val, mem;
5549   enum machine_mode old_mode;
5550   location_t loc = EXPR_LOCATION (exp);
5551
5552   if (code == NOT && warn_sync_nand)
5553     {
5554       tree fndecl = get_callee_fndecl (exp);
5555       enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5556
5557       static bool warned_f_a_n, warned_n_a_f;
5558
5559       switch (fcode)
5560         {
5561         case BUILT_IN_FETCH_AND_NAND_1:
5562         case BUILT_IN_FETCH_AND_NAND_2:
5563         case BUILT_IN_FETCH_AND_NAND_4:
5564         case BUILT_IN_FETCH_AND_NAND_8:
5565         case BUILT_IN_FETCH_AND_NAND_16:
5566
5567           if (warned_f_a_n)
5568             break;
5569
5570           fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
5571           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5572           warned_f_a_n = true;
5573           break;
5574
5575         case BUILT_IN_NAND_AND_FETCH_1:
5576         case BUILT_IN_NAND_AND_FETCH_2:
5577         case BUILT_IN_NAND_AND_FETCH_4:
5578         case BUILT_IN_NAND_AND_FETCH_8:
5579         case BUILT_IN_NAND_AND_FETCH_16:
5580
5581           if (warned_n_a_f)
5582             break;
5583
5584           fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
5585           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5586           warned_n_a_f = true;
5587           break;
5588
5589         default:
5590           gcc_unreachable ();
5591         }
5592     }
5593
5594   /* Expand the operands.  */
5595   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5596
5597   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5598   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5599      of CONST_INTs, where we know the old_mode only from the call argument.  */
5600   old_mode = GET_MODE (val);
5601   if (old_mode == VOIDmode)
5602     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5603   val = convert_modes (mode, old_mode, val, 1);
5604
5605   if (ignore)
5606     return expand_sync_operation (mem, val, code);
5607   else
5608     return expand_sync_fetch_operation (mem, val, code, after, target);
5609 }
5610
5611 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5612    intrinsics. EXP is the CALL_EXPR.  IS_BOOL is
5613    true if this is the boolean form.  TARGET is a place for us to store the
5614    results; this is NOT optional if IS_BOOL is true.  */
5615
5616 static rtx
5617 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5618                                  bool is_bool, rtx target)
5619 {
5620   rtx old_val, new_val, mem;
5621   enum machine_mode old_mode;
5622
5623   /* Expand the operands.  */
5624   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5625
5626
5627   old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX,
5628                          mode, EXPAND_NORMAL);
5629   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5630      of CONST_INTs, where we know the old_mode only from the call argument.  */
5631   old_mode = GET_MODE (old_val);
5632   if (old_mode == VOIDmode)
5633     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5634   old_val = convert_modes (mode, old_mode, old_val, 1);
5635
5636   new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL_RTX,
5637                          mode, EXPAND_NORMAL);
5638   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5639      of CONST_INTs, where we know the old_mode only from the call argument.  */
5640   old_mode = GET_MODE (new_val);
5641   if (old_mode == VOIDmode)
5642     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2)));
5643   new_val = convert_modes (mode, old_mode, new_val, 1);
5644
5645   if (is_bool)
5646     return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5647   else
5648     return expand_val_compare_and_swap (mem, old_val, new_val, target);
5649 }
5650
5651 /* Expand the __sync_lock_test_and_set intrinsic.  Note that the most
5652    general form is actually an atomic exchange, and some targets only
5653    support a reduced form with the second argument being a constant 1.
5654    EXP is the CALL_EXPR; TARGET is an optional place for us to store
5655    the results.  */
5656
5657 static rtx
5658 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
5659                                   rtx target)
5660 {
5661   rtx val, mem;
5662   enum machine_mode old_mode;
5663
5664   /* Expand the operands.  */
5665   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5666   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5667   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5668      of CONST_INTs, where we know the old_mode only from the call argument.  */
5669   old_mode = GET_MODE (val);
5670   if (old_mode == VOIDmode)
5671     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5672   val = convert_modes (mode, old_mode, val, 1);
5673
5674   return expand_sync_lock_test_and_set (mem, val, target);
5675 }
5676
5677 /* Expand the __sync_synchronize intrinsic.  */
5678
5679 static void
5680 expand_builtin_synchronize (void)
5681 {
5682   gimple x;
5683   VEC (tree, gc) *v_clobbers;
5684
5685 #ifdef HAVE_memory_barrier
5686   if (HAVE_memory_barrier)
5687     {
5688       emit_insn (gen_memory_barrier ());
5689       return;
5690     }
5691 #endif
5692
5693   if (synchronize_libfunc != NULL_RTX)
5694     {
5695       emit_library_call (synchronize_libfunc, LCT_NORMAL, VOIDmode, 0);
5696       return;
5697     }
5698
5699   /* If no explicit memory barrier instruction is available, create an
5700      empty asm stmt with a memory clobber.  */
5701   v_clobbers = VEC_alloc (tree, gc, 1);
5702   VEC_quick_push (tree, v_clobbers,
5703                   tree_cons (NULL, build_string (6, "memory"), NULL));
5704   x = gimple_build_asm_vec ("", NULL, NULL, v_clobbers, NULL);
5705   gimple_asm_set_volatile (x, true);
5706   expand_asm_stmt (x);
5707 }
5708
5709 /* Expand the __sync_lock_release intrinsic.  EXP is the CALL_EXPR.  */
5710
5711 static void
5712 expand_builtin_lock_release (enum machine_mode mode, tree exp)
5713 {
5714   enum insn_code icode;
5715   rtx mem, insn;
5716   rtx val = const0_rtx;
5717
5718   /* Expand the operands.  */
5719   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5720
5721   /* If there is an explicit operation in the md file, use it.  */
5722   icode = direct_optab_handler (sync_lock_release_optab, mode);
5723   if (icode != CODE_FOR_nothing)
5724     {
5725       if (!insn_data[icode].operand[1].predicate (val, mode))
5726         val = force_reg (mode, val);
5727
5728       insn = GEN_FCN (icode) (mem, val);
5729       if (insn)
5730         {
5731           emit_insn (insn);
5732           return;
5733         }
5734     }
5735
5736   /* Otherwise we can implement this operation by emitting a barrier
5737      followed by a store of zero.  */
5738   expand_builtin_synchronize ();
5739   emit_move_insn (mem, val);
5740 }
5741 \f
5742 /* Expand an expression EXP that calls a built-in function,
5743    with result going to TARGET if that's convenient
5744    (and in mode MODE if that's convenient).
5745    SUBTARGET may be used as the target for computing one of EXP's operands.
5746    IGNORE is nonzero if the value is to be ignored.  */
5747
5748 rtx
5749 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5750                 int ignore)
5751 {
5752   tree fndecl = get_callee_fndecl (exp);
5753   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5754   enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5755   int flags;
5756
5757   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5758     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5759
5760   /* When not optimizing, generate calls to library functions for a certain
5761      set of builtins.  */
5762   if (!optimize
5763       && !called_as_built_in (fndecl)
5764       && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5765       && fcode != BUILT_IN_ALLOCA
5766       && fcode != BUILT_IN_FREE)
5767     return expand_call (exp, target, ignore);
5768
5769   /* The built-in function expanders test for target == const0_rtx
5770      to determine whether the function's result will be ignored.  */
5771   if (ignore)
5772     target = const0_rtx;
5773
5774   /* If the result of a pure or const built-in function is ignored, and
5775      none of its arguments are volatile, we can avoid expanding the
5776      built-in call and just evaluate the arguments for side-effects.  */
5777   if (target == const0_rtx
5778       && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5779       && !(flags & ECF_LOOPING_CONST_OR_PURE))
5780     {
5781       bool volatilep = false;
5782       tree arg;
5783       call_expr_arg_iterator iter;
5784
5785       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5786         if (TREE_THIS_VOLATILE (arg))
5787           {
5788             volatilep = true;
5789             break;
5790           }
5791
5792       if (! volatilep)
5793         {
5794           FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5795             expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5796           return const0_rtx;
5797         }
5798     }
5799
5800   switch (fcode)
5801     {
5802     CASE_FLT_FN (BUILT_IN_FABS):
5803       target = expand_builtin_fabs (exp, target, subtarget);
5804       if (target)
5805         return target;
5806       break;
5807
5808     CASE_FLT_FN (BUILT_IN_COPYSIGN):
5809       target = expand_builtin_copysign (exp, target, subtarget);
5810       if (target)
5811         return target;
5812       break;
5813
5814       /* Just do a normal library call if we were unable to fold
5815          the values.  */
5816     CASE_FLT_FN (BUILT_IN_CABS):
5817       break;
5818
5819     CASE_FLT_FN (BUILT_IN_EXP):
5820     CASE_FLT_FN (BUILT_IN_EXP10):
5821     CASE_FLT_FN (BUILT_IN_POW10):
5822     CASE_FLT_FN (BUILT_IN_EXP2):
5823     CASE_FLT_FN (BUILT_IN_EXPM1):
5824     CASE_FLT_FN (BUILT_IN_LOGB):
5825     CASE_FLT_FN (BUILT_IN_LOG):
5826     CASE_FLT_FN (BUILT_IN_LOG10):
5827     CASE_FLT_FN (BUILT_IN_LOG2):
5828     CASE_FLT_FN (BUILT_IN_LOG1P):
5829     CASE_FLT_FN (BUILT_IN_TAN):
5830     CASE_FLT_FN (BUILT_IN_ASIN):
5831     CASE_FLT_FN (BUILT_IN_ACOS):
5832     CASE_FLT_FN (BUILT_IN_ATAN):
5833     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5834       /* Treat these like sqrt only if unsafe math optimizations are allowed,
5835          because of possible accuracy problems.  */
5836       if (! flag_unsafe_math_optimizations)
5837         break;
5838     CASE_FLT_FN (BUILT_IN_SQRT):
5839     CASE_FLT_FN (BUILT_IN_FLOOR):
5840     CASE_FLT_FN (BUILT_IN_CEIL):
5841     CASE_FLT_FN (BUILT_IN_TRUNC):
5842     CASE_FLT_FN (BUILT_IN_ROUND):
5843     CASE_FLT_FN (BUILT_IN_NEARBYINT):
5844     CASE_FLT_FN (BUILT_IN_RINT):
5845       target = expand_builtin_mathfn (exp, target, subtarget);
5846       if (target)
5847         return target;
5848       break;
5849
5850     CASE_FLT_FN (BUILT_IN_ILOGB):
5851       if (! flag_unsafe_math_optimizations)
5852         break;
5853     CASE_FLT_FN (BUILT_IN_ISINF):
5854     CASE_FLT_FN (BUILT_IN_FINITE):
5855     case BUILT_IN_ISFINITE:
5856     case BUILT_IN_ISNORMAL:
5857       target = expand_builtin_interclass_mathfn (exp, target, subtarget);
5858       if (target)
5859         return target;
5860       break;
5861
5862     CASE_FLT_FN (BUILT_IN_LCEIL):
5863     CASE_FLT_FN (BUILT_IN_LLCEIL):
5864     CASE_FLT_FN (BUILT_IN_LFLOOR):
5865     CASE_FLT_FN (BUILT_IN_LLFLOOR):
5866       target = expand_builtin_int_roundingfn (exp, target);
5867       if (target)
5868         return target;
5869       break;
5870
5871     CASE_FLT_FN (BUILT_IN_LRINT):
5872     CASE_FLT_FN (BUILT_IN_LLRINT):
5873     CASE_FLT_FN (BUILT_IN_LROUND):
5874     CASE_FLT_FN (BUILT_IN_LLROUND):
5875       target = expand_builtin_int_roundingfn_2 (exp, target);
5876       if (target)
5877         return target;
5878       break;
5879
5880     CASE_FLT_FN (BUILT_IN_POW):
5881       target = expand_builtin_pow (exp, target, subtarget);
5882       if (target)
5883         return target;
5884       break;
5885
5886     CASE_FLT_FN (BUILT_IN_POWI):
5887       target = expand_builtin_powi (exp, target, subtarget);
5888       if (target)
5889         return target;
5890       break;
5891
5892     CASE_FLT_FN (BUILT_IN_ATAN2):
5893     CASE_FLT_FN (BUILT_IN_LDEXP):
5894     CASE_FLT_FN (BUILT_IN_SCALB):
5895     CASE_FLT_FN (BUILT_IN_SCALBN):
5896     CASE_FLT_FN (BUILT_IN_SCALBLN):
5897       if (! flag_unsafe_math_optimizations)
5898         break;
5899
5900     CASE_FLT_FN (BUILT_IN_FMOD):
5901     CASE_FLT_FN (BUILT_IN_REMAINDER):
5902     CASE_FLT_FN (BUILT_IN_DREM):
5903       target = expand_builtin_mathfn_2 (exp, target, subtarget);
5904       if (target)
5905         return target;
5906       break;
5907
5908     CASE_FLT_FN (BUILT_IN_CEXPI):
5909       target = expand_builtin_cexpi (exp, target, subtarget);
5910       gcc_assert (target);
5911       return target;
5912
5913     CASE_FLT_FN (BUILT_IN_SIN):
5914     CASE_FLT_FN (BUILT_IN_COS):
5915       if (! flag_unsafe_math_optimizations)
5916         break;
5917       target = expand_builtin_mathfn_3 (exp, target, subtarget);
5918       if (target)
5919         return target;
5920       break;
5921
5922     CASE_FLT_FN (BUILT_IN_SINCOS):
5923       if (! flag_unsafe_math_optimizations)
5924         break;
5925       target = expand_builtin_sincos (exp);
5926       if (target)
5927         return target;
5928       break;
5929
5930     case BUILT_IN_APPLY_ARGS:
5931       return expand_builtin_apply_args ();
5932
5933       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5934          FUNCTION with a copy of the parameters described by
5935          ARGUMENTS, and ARGSIZE.  It returns a block of memory
5936          allocated on the stack into which is stored all the registers
5937          that might possibly be used for returning the result of a
5938          function.  ARGUMENTS is the value returned by
5939          __builtin_apply_args.  ARGSIZE is the number of bytes of
5940          arguments that must be copied.  ??? How should this value be
5941          computed?  We'll also need a safe worst case value for varargs
5942          functions.  */
5943     case BUILT_IN_APPLY:
5944       if (!validate_arglist (exp, POINTER_TYPE,
5945                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5946           && !validate_arglist (exp, REFERENCE_TYPE,
5947                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5948         return const0_rtx;
5949       else
5950         {
5951           rtx ops[3];
5952
5953           ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
5954           ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
5955           ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
5956
5957           return expand_builtin_apply (ops[0], ops[1], ops[2]);
5958         }
5959
5960       /* __builtin_return (RESULT) causes the function to return the
5961          value described by RESULT.  RESULT is address of the block of
5962          memory returned by __builtin_apply.  */
5963     case BUILT_IN_RETURN:
5964       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5965         expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
5966       return const0_rtx;
5967
5968     case BUILT_IN_SAVEREGS:
5969       return expand_builtin_saveregs ();
5970
5971     case BUILT_IN_VA_ARG_PACK:
5972       /* All valid uses of __builtin_va_arg_pack () are removed during
5973          inlining.  */
5974       error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
5975       return const0_rtx;
5976
5977     case BUILT_IN_VA_ARG_PACK_LEN:
5978       /* All valid uses of __builtin_va_arg_pack_len () are removed during
5979          inlining.  */
5980       error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
5981       return const0_rtx;
5982
5983       /* Return the address of the first anonymous stack arg.  */
5984     case BUILT_IN_NEXT_ARG:
5985       if (fold_builtin_next_arg (exp, false))
5986         return const0_rtx;
5987       return expand_builtin_next_arg ();
5988
5989     case BUILT_IN_CLEAR_CACHE:
5990       target = expand_builtin___clear_cache (exp);
5991       if (target)
5992         return target;
5993       break;
5994
5995     case BUILT_IN_CLASSIFY_TYPE:
5996       return expand_builtin_classify_type (exp);
5997
5998     case BUILT_IN_CONSTANT_P:
5999       return const0_rtx;
6000
6001     case BUILT_IN_FRAME_ADDRESS:
6002     case BUILT_IN_RETURN_ADDRESS:
6003       return expand_builtin_frame_address (fndecl, exp);
6004
6005     /* Returns the address of the area where the structure is returned.
6006        0 otherwise.  */
6007     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
6008       if (call_expr_nargs (exp) != 0
6009           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
6010           || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
6011         return const0_rtx;
6012       else
6013         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6014
6015     case BUILT_IN_ALLOCA:
6016       /* If the allocation stems from the declaration of a variable-sized
6017          object, it cannot accumulate.  */
6018       target = expand_builtin_alloca (exp, target, ALLOCA_FOR_VAR_P (exp));
6019       if (target)
6020         return target;
6021       break;
6022
6023     case BUILT_IN_STACK_SAVE:
6024       return expand_stack_save ();
6025
6026     case BUILT_IN_STACK_RESTORE:
6027       expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6028       return const0_rtx;
6029
6030     case BUILT_IN_BSWAP32:
6031     case BUILT_IN_BSWAP64:
6032       target = expand_builtin_bswap (exp, target, subtarget);
6033
6034       if (target)
6035         return target;
6036       break;
6037
6038     CASE_INT_FN (BUILT_IN_FFS):
6039     case BUILT_IN_FFSIMAX:
6040       target = expand_builtin_unop (target_mode, exp, target,
6041                                     subtarget, ffs_optab);
6042       if (target)
6043         return target;
6044       break;
6045
6046     CASE_INT_FN (BUILT_IN_CLZ):
6047     case BUILT_IN_CLZIMAX:
6048       target = expand_builtin_unop (target_mode, exp, target,
6049                                     subtarget, clz_optab);
6050       if (target)
6051         return target;
6052       break;
6053
6054     CASE_INT_FN (BUILT_IN_CTZ):
6055     case BUILT_IN_CTZIMAX:
6056       target = expand_builtin_unop (target_mode, exp, target,
6057                                     subtarget, ctz_optab);
6058       if (target)
6059         return target;
6060       break;
6061
6062     CASE_INT_FN (BUILT_IN_POPCOUNT):
6063     case BUILT_IN_POPCOUNTIMAX:
6064       target = expand_builtin_unop (target_mode, exp, target,
6065                                     subtarget, popcount_optab);
6066       if (target)
6067         return target;
6068       break;
6069
6070     CASE_INT_FN (BUILT_IN_PARITY):
6071     case BUILT_IN_PARITYIMAX:
6072       target = expand_builtin_unop (target_mode, exp, target,
6073                                     subtarget, parity_optab);
6074       if (target)
6075         return target;
6076       break;
6077
6078     case BUILT_IN_STRLEN:
6079       target = expand_builtin_strlen (exp, target, target_mode);
6080       if (target)
6081         return target;
6082       break;
6083
6084     case BUILT_IN_STRCPY:
6085       target = expand_builtin_strcpy (exp, target);
6086       if (target)
6087         return target;
6088       break;
6089
6090     case BUILT_IN_STRNCPY:
6091       target = expand_builtin_strncpy (exp, target);
6092       if (target)
6093         return target;
6094       break;
6095
6096     case BUILT_IN_STPCPY:
6097       target = expand_builtin_stpcpy (exp, target, mode);
6098       if (target)
6099         return target;
6100       break;
6101
6102     case BUILT_IN_MEMCPY:
6103       target = expand_builtin_memcpy (exp, target);
6104       if (target)
6105         return target;
6106       break;
6107
6108     case BUILT_IN_MEMPCPY:
6109       target = expand_builtin_mempcpy (exp, target, mode);
6110       if (target)
6111         return target;
6112       break;
6113
6114     case BUILT_IN_MEMSET:
6115       target = expand_builtin_memset (exp, target, mode);
6116       if (target)
6117         return target;
6118       break;
6119
6120     case BUILT_IN_BZERO:
6121       target = expand_builtin_bzero (exp);
6122       if (target)
6123         return target;
6124       break;
6125
6126     case BUILT_IN_STRCMP:
6127       target = expand_builtin_strcmp (exp, target);
6128       if (target)
6129         return target;
6130       break;
6131
6132     case BUILT_IN_STRNCMP:
6133       target = expand_builtin_strncmp (exp, target, mode);
6134       if (target)
6135         return target;
6136       break;
6137
6138     case BUILT_IN_BCMP:
6139     case BUILT_IN_MEMCMP:
6140       target = expand_builtin_memcmp (exp, target, mode);
6141       if (target)
6142         return target;
6143       break;
6144
6145     case BUILT_IN_SETJMP:
6146       /* This should have been lowered to the builtins below.  */
6147       gcc_unreachable ();
6148
6149     case BUILT_IN_SETJMP_SETUP:
6150       /* __builtin_setjmp_setup is passed a pointer to an array of five words
6151           and the receiver label.  */
6152       if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6153         {
6154           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6155                                       VOIDmode, EXPAND_NORMAL);
6156           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6157           rtx label_r = label_rtx (label);
6158
6159           /* This is copied from the handling of non-local gotos.  */
6160           expand_builtin_setjmp_setup (buf_addr, label_r);
6161           nonlocal_goto_handler_labels
6162             = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6163                                  nonlocal_goto_handler_labels);
6164           /* ??? Do not let expand_label treat us as such since we would
6165              not want to be both on the list of non-local labels and on
6166              the list of forced labels.  */
6167           FORCED_LABEL (label) = 0;
6168           return const0_rtx;
6169         }
6170       break;
6171
6172     case BUILT_IN_SETJMP_DISPATCHER:
6173        /* __builtin_setjmp_dispatcher is passed the dispatcher label.  */
6174       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6175         {
6176           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6177           rtx label_r = label_rtx (label);
6178
6179           /* Remove the dispatcher label from the list of non-local labels
6180              since the receiver labels have been added to it above.  */
6181           remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6182           return const0_rtx;
6183         }
6184       break;
6185
6186     case BUILT_IN_SETJMP_RECEIVER:
6187        /* __builtin_setjmp_receiver is passed the receiver label.  */
6188       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6189         {
6190           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6191           rtx label_r = label_rtx (label);
6192
6193           expand_builtin_setjmp_receiver (label_r);
6194           return const0_rtx;
6195         }
6196       break;
6197
6198       /* __builtin_longjmp is passed a pointer to an array of five words.
6199          It's similar to the C library longjmp function but works with
6200          __builtin_setjmp above.  */
6201     case BUILT_IN_LONGJMP:
6202       if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6203         {
6204           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6205                                       VOIDmode, EXPAND_NORMAL);
6206           rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6207
6208           if (value != const1_rtx)
6209             {
6210               error ("%<__builtin_longjmp%> second argument must be 1");
6211               return const0_rtx;
6212             }
6213
6214           expand_builtin_longjmp (buf_addr, value);
6215           return const0_rtx;
6216         }
6217       break;
6218
6219     case BUILT_IN_NONLOCAL_GOTO:
6220       target = expand_builtin_nonlocal_goto (exp);
6221       if (target)
6222         return target;
6223       break;
6224
6225       /* This updates the setjmp buffer that is its argument with the value
6226          of the current stack pointer.  */
6227     case BUILT_IN_UPDATE_SETJMP_BUF:
6228       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6229         {
6230           rtx buf_addr
6231             = expand_normal (CALL_EXPR_ARG (exp, 0));
6232
6233           expand_builtin_update_setjmp_buf (buf_addr);
6234           return const0_rtx;
6235         }
6236       break;
6237
6238     case BUILT_IN_TRAP:
6239       expand_builtin_trap ();
6240       return const0_rtx;
6241
6242     case BUILT_IN_UNREACHABLE:
6243       expand_builtin_unreachable ();
6244       return const0_rtx;
6245
6246     CASE_FLT_FN (BUILT_IN_SIGNBIT):
6247     case BUILT_IN_SIGNBITD32:
6248     case BUILT_IN_SIGNBITD64:
6249     case BUILT_IN_SIGNBITD128:
6250       target = expand_builtin_signbit (exp, target);
6251       if (target)
6252         return target;
6253       break;
6254
6255       /* Various hooks for the DWARF 2 __throw routine.  */
6256     case BUILT_IN_UNWIND_INIT:
6257       expand_builtin_unwind_init ();
6258       return const0_rtx;
6259     case BUILT_IN_DWARF_CFA:
6260       return virtual_cfa_rtx;
6261 #ifdef DWARF2_UNWIND_INFO
6262     case BUILT_IN_DWARF_SP_COLUMN:
6263       return expand_builtin_dwarf_sp_column ();
6264     case BUILT_IN_INIT_DWARF_REG_SIZES:
6265       expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6266       return const0_rtx;
6267 #endif
6268     case BUILT_IN_FROB_RETURN_ADDR:
6269       return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6270     case BUILT_IN_EXTRACT_RETURN_ADDR:
6271       return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6272     case BUILT_IN_EH_RETURN:
6273       expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6274                                 CALL_EXPR_ARG (exp, 1));
6275       return const0_rtx;
6276 #ifdef EH_RETURN_DATA_REGNO
6277     case BUILT_IN_EH_RETURN_DATA_REGNO:
6278       return expand_builtin_eh_return_data_regno (exp);
6279 #endif
6280     case BUILT_IN_EXTEND_POINTER:
6281       return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6282     case BUILT_IN_EH_POINTER:
6283       return expand_builtin_eh_pointer (exp);
6284     case BUILT_IN_EH_FILTER:
6285       return expand_builtin_eh_filter (exp);
6286     case BUILT_IN_EH_COPY_VALUES:
6287       return expand_builtin_eh_copy_values (exp);
6288
6289     case BUILT_IN_VA_START:
6290       return expand_builtin_va_start (exp);
6291     case BUILT_IN_VA_END:
6292       return expand_builtin_va_end (exp);
6293     case BUILT_IN_VA_COPY:
6294       return expand_builtin_va_copy (exp);
6295     case BUILT_IN_EXPECT:
6296       return expand_builtin_expect (exp, target);
6297     case BUILT_IN_PREFETCH:
6298       expand_builtin_prefetch (exp);
6299       return const0_rtx;
6300
6301     case BUILT_IN_PROFILE_FUNC_ENTER:
6302       return expand_builtin_profile_func (false);
6303     case BUILT_IN_PROFILE_FUNC_EXIT:
6304       return expand_builtin_profile_func (true);
6305
6306     case BUILT_IN_INIT_TRAMPOLINE:
6307       return expand_builtin_init_trampoline (exp);
6308     case BUILT_IN_ADJUST_TRAMPOLINE:
6309       return expand_builtin_adjust_trampoline (exp);
6310
6311     case BUILT_IN_FORK:
6312     case BUILT_IN_EXECL:
6313     case BUILT_IN_EXECV:
6314     case BUILT_IN_EXECLP:
6315     case BUILT_IN_EXECLE:
6316     case BUILT_IN_EXECVP:
6317     case BUILT_IN_EXECVE:
6318       target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6319       if (target)
6320         return target;
6321       break;
6322
6323     case BUILT_IN_FETCH_AND_ADD_1:
6324     case BUILT_IN_FETCH_AND_ADD_2:
6325     case BUILT_IN_FETCH_AND_ADD_4:
6326     case BUILT_IN_FETCH_AND_ADD_8:
6327     case BUILT_IN_FETCH_AND_ADD_16:
6328       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6329       target = expand_builtin_sync_operation (mode, exp, PLUS,
6330                                               false, target, ignore);
6331       if (target)
6332         return target;
6333       break;
6334
6335     case BUILT_IN_FETCH_AND_SUB_1:
6336     case BUILT_IN_FETCH_AND_SUB_2:
6337     case BUILT_IN_FETCH_AND_SUB_4:
6338     case BUILT_IN_FETCH_AND_SUB_8:
6339     case BUILT_IN_FETCH_AND_SUB_16:
6340       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6341       target = expand_builtin_sync_operation (mode, exp, MINUS,
6342                                               false, target, ignore);
6343       if (target)
6344         return target;
6345       break;
6346
6347     case BUILT_IN_FETCH_AND_OR_1:
6348     case BUILT_IN_FETCH_AND_OR_2:
6349     case BUILT_IN_FETCH_AND_OR_4:
6350     case BUILT_IN_FETCH_AND_OR_8:
6351     case BUILT_IN_FETCH_AND_OR_16:
6352       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6353       target = expand_builtin_sync_operation (mode, exp, IOR,
6354                                               false, target, ignore);
6355       if (target)
6356         return target;
6357       break;
6358
6359     case BUILT_IN_FETCH_AND_AND_1:
6360     case BUILT_IN_FETCH_AND_AND_2:
6361     case BUILT_IN_FETCH_AND_AND_4:
6362     case BUILT_IN_FETCH_AND_AND_8:
6363     case BUILT_IN_FETCH_AND_AND_16:
6364       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6365       target = expand_builtin_sync_operation (mode, exp, AND,
6366                                               false, target, ignore);
6367       if (target)
6368         return target;
6369       break;
6370
6371     case BUILT_IN_FETCH_AND_XOR_1:
6372     case BUILT_IN_FETCH_AND_XOR_2:
6373     case BUILT_IN_FETCH_AND_XOR_4:
6374     case BUILT_IN_FETCH_AND_XOR_8:
6375     case BUILT_IN_FETCH_AND_XOR_16:
6376       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6377       target = expand_builtin_sync_operation (mode, exp, XOR,
6378                                               false, target, ignore);
6379       if (target)
6380         return target;
6381       break;
6382
6383     case BUILT_IN_FETCH_AND_NAND_1:
6384     case BUILT_IN_FETCH_AND_NAND_2:
6385     case BUILT_IN_FETCH_AND_NAND_4:
6386     case BUILT_IN_FETCH_AND_NAND_8:
6387     case BUILT_IN_FETCH_AND_NAND_16:
6388       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6389       target = expand_builtin_sync_operation (mode, exp, NOT,
6390                                               false, target, ignore);
6391       if (target)
6392         return target;
6393       break;
6394
6395     case BUILT_IN_ADD_AND_FETCH_1:
6396     case BUILT_IN_ADD_AND_FETCH_2:
6397     case BUILT_IN_ADD_AND_FETCH_4:
6398     case BUILT_IN_ADD_AND_FETCH_8:
6399     case BUILT_IN_ADD_AND_FETCH_16:
6400       mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6401       target = expand_builtin_sync_operation (mode, exp, PLUS,
6402                                               true, target, ignore);
6403       if (target)
6404         return target;
6405       break;
6406
6407     case BUILT_IN_SUB_AND_FETCH_1:
6408     case BUILT_IN_SUB_AND_FETCH_2:
6409     case BUILT_IN_SUB_AND_FETCH_4:
6410     case BUILT_IN_SUB_AND_FETCH_8:
6411     case BUILT_IN_SUB_AND_FETCH_16:
6412       mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6413       target = expand_builtin_sync_operation (mode, exp, MINUS,
6414                                               true, target, ignore);
6415       if (target)
6416         return target;
6417       break;
6418
6419     case BUILT_IN_OR_AND_FETCH_1:
6420     case BUILT_IN_OR_AND_FETCH_2:
6421     case BUILT_IN_OR_AND_FETCH_4:
6422     case BUILT_IN_OR_AND_FETCH_8:
6423     case BUILT_IN_OR_AND_FETCH_16:
6424       mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6425       target = expand_builtin_sync_operation (mode, exp, IOR,
6426                                               true, target, ignore);
6427       if (target)
6428         return target;
6429       break;
6430
6431     case BUILT_IN_AND_AND_FETCH_1:
6432     case BUILT_IN_AND_AND_FETCH_2:
6433     case BUILT_IN_AND_AND_FETCH_4:
6434     case BUILT_IN_AND_AND_FETCH_8:
6435     case BUILT_IN_AND_AND_FETCH_16:
6436       mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6437       target = expand_builtin_sync_operation (mode, exp, AND,
6438                                               true, target, ignore);
6439       if (target)
6440         return target;
6441       break;
6442
6443     case BUILT_IN_XOR_AND_FETCH_1:
6444     case BUILT_IN_XOR_AND_FETCH_2:
6445     case BUILT_IN_XOR_AND_FETCH_4:
6446     case BUILT_IN_XOR_AND_FETCH_8:
6447     case BUILT_IN_XOR_AND_FETCH_16:
6448       mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6449       target = expand_builtin_sync_operation (mode, exp, XOR,
6450                                               true, target, ignore);
6451       if (target)
6452         return target;
6453       break;
6454
6455     case BUILT_IN_NAND_AND_FETCH_1:
6456     case BUILT_IN_NAND_AND_FETCH_2:
6457     case BUILT_IN_NAND_AND_FETCH_4:
6458     case BUILT_IN_NAND_AND_FETCH_8:
6459     case BUILT_IN_NAND_AND_FETCH_16:
6460       mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6461       target = expand_builtin_sync_operation (mode, exp, NOT,
6462                                               true, target, ignore);
6463       if (target)
6464         return target;
6465       break;
6466
6467     case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6468     case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6469     case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6470     case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6471     case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6472       if (mode == VOIDmode)
6473         mode = TYPE_MODE (boolean_type_node);
6474       if (!target || !register_operand (target, mode))
6475         target = gen_reg_rtx (mode);
6476
6477       mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6478       target = expand_builtin_compare_and_swap (mode, exp, true, target);
6479       if (target)
6480         return target;
6481       break;
6482
6483     case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6484     case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6485     case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6486     case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6487     case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6488       mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6489       target = expand_builtin_compare_and_swap (mode, exp, false, target);
6490       if (target)
6491         return target;
6492       break;
6493
6494     case BUILT_IN_LOCK_TEST_AND_SET_1:
6495     case BUILT_IN_LOCK_TEST_AND_SET_2:
6496     case BUILT_IN_LOCK_TEST_AND_SET_4:
6497     case BUILT_IN_LOCK_TEST_AND_SET_8:
6498     case BUILT_IN_LOCK_TEST_AND_SET_16:
6499       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6500       target = expand_builtin_lock_test_and_set (mode, exp, target);
6501       if (target)
6502         return target;
6503       break;
6504
6505     case BUILT_IN_LOCK_RELEASE_1:
6506     case BUILT_IN_LOCK_RELEASE_2:
6507     case BUILT_IN_LOCK_RELEASE_4:
6508     case BUILT_IN_LOCK_RELEASE_8:
6509     case BUILT_IN_LOCK_RELEASE_16:
6510       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6511       expand_builtin_lock_release (mode, exp);
6512       return const0_rtx;
6513
6514     case BUILT_IN_SYNCHRONIZE:
6515       expand_builtin_synchronize ();
6516       return const0_rtx;
6517
6518     case BUILT_IN_OBJECT_SIZE:
6519       return expand_builtin_object_size (exp);
6520
6521     case BUILT_IN_MEMCPY_CHK:
6522     case BUILT_IN_MEMPCPY_CHK:
6523     case BUILT_IN_MEMMOVE_CHK:
6524     case BUILT_IN_MEMSET_CHK:
6525       target = expand_builtin_memory_chk (exp, target, mode, fcode);
6526       if (target)
6527         return target;
6528       break;
6529
6530     case BUILT_IN_STRCPY_CHK:
6531     case BUILT_IN_STPCPY_CHK:
6532     case BUILT_IN_STRNCPY_CHK:
6533     case BUILT_IN_STRCAT_CHK:
6534     case BUILT_IN_STRNCAT_CHK:
6535     case BUILT_IN_SNPRINTF_CHK:
6536     case BUILT_IN_VSNPRINTF_CHK:
6537       maybe_emit_chk_warning (exp, fcode);
6538       break;
6539
6540     case BUILT_IN_SPRINTF_CHK:
6541     case BUILT_IN_VSPRINTF_CHK:
6542       maybe_emit_sprintf_chk_warning (exp, fcode);
6543       break;
6544
6545     case BUILT_IN_FREE:
6546       maybe_emit_free_warning (exp);
6547       break;
6548
6549     default:    /* just do library call, if unknown builtin */
6550       break;
6551     }
6552
6553   /* The switch statement above can drop through to cause the function
6554      to be called normally.  */
6555   return expand_call (exp, target, ignore);
6556 }
6557
6558 /* Determine whether a tree node represents a call to a built-in
6559    function.  If the tree T is a call to a built-in function with
6560    the right number of arguments of the appropriate types, return
6561    the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6562    Otherwise the return value is END_BUILTINS.  */
6563
6564 enum built_in_function
6565 builtin_mathfn_code (const_tree t)
6566 {
6567   const_tree fndecl, arg, parmlist;
6568   const_tree argtype, parmtype;
6569   const_call_expr_arg_iterator iter;
6570
6571   if (TREE_CODE (t) != CALL_EXPR
6572       || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6573     return END_BUILTINS;
6574
6575   fndecl = get_callee_fndecl (t);
6576   if (fndecl == NULL_TREE
6577       || TREE_CODE (fndecl) != FUNCTION_DECL
6578       || ! DECL_BUILT_IN (fndecl)
6579       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6580     return END_BUILTINS;
6581
6582   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6583   init_const_call_expr_arg_iterator (t, &iter);
6584   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6585     {
6586       /* If a function doesn't take a variable number of arguments,
6587          the last element in the list will have type `void'.  */
6588       parmtype = TREE_VALUE (parmlist);
6589       if (VOID_TYPE_P (parmtype))
6590         {
6591           if (more_const_call_expr_args_p (&iter))
6592             return END_BUILTINS;
6593           return DECL_FUNCTION_CODE (fndecl);
6594         }
6595
6596       if (! more_const_call_expr_args_p (&iter))
6597         return END_BUILTINS;
6598
6599       arg = next_const_call_expr_arg (&iter);
6600       argtype = TREE_TYPE (arg);
6601
6602       if (SCALAR_FLOAT_TYPE_P (parmtype))
6603         {
6604           if (! SCALAR_FLOAT_TYPE_P (argtype))
6605             return END_BUILTINS;
6606         }
6607       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6608         {
6609           if (! COMPLEX_FLOAT_TYPE_P (argtype))
6610             return END_BUILTINS;
6611         }
6612       else if (POINTER_TYPE_P (parmtype))
6613         {
6614           if (! POINTER_TYPE_P (argtype))
6615             return END_BUILTINS;
6616         }
6617       else if (INTEGRAL_TYPE_P (parmtype))
6618         {
6619           if (! INTEGRAL_TYPE_P (argtype))
6620             return END_BUILTINS;
6621         }
6622       else
6623         return END_BUILTINS;
6624     }
6625
6626   /* Variable-length argument list.  */
6627   return DECL_FUNCTION_CODE (fndecl);
6628 }
6629
6630 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6631    evaluate to a constant.  */
6632
6633 static tree
6634 fold_builtin_constant_p (tree arg)
6635 {
6636   /* We return 1 for a numeric type that's known to be a constant
6637      value at compile-time or for an aggregate type that's a
6638      literal constant.  */
6639   STRIP_NOPS (arg);
6640
6641   /* If we know this is a constant, emit the constant of one.  */
6642   if (CONSTANT_CLASS_P (arg)
6643       || (TREE_CODE (arg) == CONSTRUCTOR
6644           && TREE_CONSTANT (arg)))
6645     return integer_one_node;
6646   if (TREE_CODE (arg) == ADDR_EXPR)
6647     {
6648        tree op = TREE_OPERAND (arg, 0);
6649        if (TREE_CODE (op) == STRING_CST
6650            || (TREE_CODE (op) == ARRAY_REF
6651                && integer_zerop (TREE_OPERAND (op, 1))
6652                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6653          return integer_one_node;
6654     }
6655
6656   /* If this expression has side effects, show we don't know it to be a
6657      constant.  Likewise if it's a pointer or aggregate type since in
6658      those case we only want literals, since those are only optimized
6659      when generating RTL, not later.
6660      And finally, if we are compiling an initializer, not code, we
6661      need to return a definite result now; there's not going to be any
6662      more optimization done.  */
6663   if (TREE_SIDE_EFFECTS (arg)
6664       || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6665       || POINTER_TYPE_P (TREE_TYPE (arg))
6666       || cfun == 0
6667       || folding_initializer)
6668     return integer_zero_node;
6669
6670   return NULL_TREE;
6671 }
6672
6673 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6674    return it as a truthvalue.  */
6675
6676 static tree
6677 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6678 {
6679   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6680
6681   fn = built_in_decls[BUILT_IN_EXPECT];
6682   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6683   ret_type = TREE_TYPE (TREE_TYPE (fn));
6684   pred_type = TREE_VALUE (arg_types);
6685   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6686
6687   pred = fold_convert_loc (loc, pred_type, pred);
6688   expected = fold_convert_loc (loc, expected_type, expected);
6689   call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6690
6691   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6692                  build_int_cst (ret_type, 0));
6693 }
6694
6695 /* Fold a call to builtin_expect with arguments ARG0 and ARG1.  Return
6696    NULL_TREE if no simplification is possible.  */
6697
6698 static tree
6699 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
6700 {
6701   tree inner, fndecl;
6702   enum tree_code code;
6703
6704   /* If this is a builtin_expect within a builtin_expect keep the
6705      inner one.  See through a comparison against a constant.  It
6706      might have been added to create a thruthvalue.  */
6707   inner = arg0;
6708   if (COMPARISON_CLASS_P (inner)
6709       && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6710     inner = TREE_OPERAND (inner, 0);
6711
6712   if (TREE_CODE (inner) == CALL_EXPR
6713       && (fndecl = get_callee_fndecl (inner))
6714       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6715       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6716     return arg0;
6717
6718   /* Distribute the expected value over short-circuiting operators.
6719      See through the cast from truthvalue_type_node to long.  */
6720   inner = arg0;
6721   while (TREE_CODE (inner) == NOP_EXPR
6722          && INTEGRAL_TYPE_P (TREE_TYPE (inner))
6723          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
6724     inner = TREE_OPERAND (inner, 0);
6725
6726   code = TREE_CODE (inner);
6727   if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6728     {
6729       tree op0 = TREE_OPERAND (inner, 0);
6730       tree op1 = TREE_OPERAND (inner, 1);
6731
6732       op0 = build_builtin_expect_predicate (loc, op0, arg1);
6733       op1 = build_builtin_expect_predicate (loc, op1, arg1);
6734       inner = build2 (code, TREE_TYPE (inner), op0, op1);
6735
6736       return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6737     }
6738
6739   /* If the argument isn't invariant then there's nothing else we can do.  */
6740   if (!TREE_CONSTANT (arg0))
6741     return NULL_TREE;
6742
6743   /* If we expect that a comparison against the argument will fold to
6744      a constant return the constant.  In practice, this means a true
6745      constant or the address of a non-weak symbol.  */
6746   inner = arg0;
6747   STRIP_NOPS (inner);
6748   if (TREE_CODE (inner) == ADDR_EXPR)
6749     {
6750       do
6751         {
6752           inner = TREE_OPERAND (inner, 0);
6753         }
6754       while (TREE_CODE (inner) == COMPONENT_REF
6755              || TREE_CODE (inner) == ARRAY_REF);
6756       if ((TREE_CODE (inner) == VAR_DECL
6757            || TREE_CODE (inner) == FUNCTION_DECL)
6758           && DECL_WEAK (inner))
6759         return NULL_TREE;
6760     }
6761
6762   /* Otherwise, ARG0 already has the proper type for the return value.  */
6763   return arg0;
6764 }
6765
6766 /* Fold a call to __builtin_classify_type with argument ARG.  */
6767
6768 static tree
6769 fold_builtin_classify_type (tree arg)
6770 {
6771   if (arg == 0)
6772     return build_int_cst (NULL_TREE, no_type_class);
6773
6774   return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
6775 }
6776
6777 /* Fold a call to __builtin_strlen with argument ARG.  */
6778
6779 static tree
6780 fold_builtin_strlen (location_t loc, tree type, tree arg)
6781 {
6782   if (!validate_arg (arg, POINTER_TYPE))
6783     return NULL_TREE;
6784   else
6785     {
6786       tree len = c_strlen (arg, 0);
6787
6788       if (len)
6789         return fold_convert_loc (loc, type, len);
6790
6791       return NULL_TREE;
6792     }
6793 }
6794
6795 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
6796
6797 static tree
6798 fold_builtin_inf (location_t loc, tree type, int warn)
6799 {
6800   REAL_VALUE_TYPE real;
6801
6802   /* __builtin_inff is intended to be usable to define INFINITY on all
6803      targets.  If an infinity is not available, INFINITY expands "to a
6804      positive constant of type float that overflows at translation
6805      time", footnote "In this case, using INFINITY will violate the
6806      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6807      Thus we pedwarn to ensure this constraint violation is
6808      diagnosed.  */
6809   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6810     pedwarn (loc, 0, "target format does not support infinity");
6811
6812   real_inf (&real);
6813   return build_real (type, real);
6814 }
6815
6816 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG.  */
6817
6818 static tree
6819 fold_builtin_nan (tree arg, tree type, int quiet)
6820 {
6821   REAL_VALUE_TYPE real;
6822   const char *str;
6823
6824   if (!validate_arg (arg, POINTER_TYPE))
6825     return NULL_TREE;
6826   str = c_getstr (arg);
6827   if (!str)
6828     return NULL_TREE;
6829
6830   if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
6831     return NULL_TREE;
6832
6833   return build_real (type, real);
6834 }
6835
6836 /* Return true if the floating point expression T has an integer value.
6837    We also allow +Inf, -Inf and NaN to be considered integer values.  */
6838
6839 static bool
6840 integer_valued_real_p (tree t)
6841 {
6842   switch (TREE_CODE (t))
6843     {
6844     case FLOAT_EXPR:
6845       return true;
6846
6847     case ABS_EXPR:
6848     case SAVE_EXPR:
6849       return integer_valued_real_p (TREE_OPERAND (t, 0));
6850
6851     case COMPOUND_EXPR:
6852     case MODIFY_EXPR:
6853     case BIND_EXPR:
6854       return integer_valued_real_p (TREE_OPERAND (t, 1));
6855
6856     case PLUS_EXPR:
6857     case MINUS_EXPR:
6858     case MULT_EXPR:
6859     case MIN_EXPR:
6860     case MAX_EXPR:
6861       return integer_valued_real_p (TREE_OPERAND (t, 0))
6862              && integer_valued_real_p (TREE_OPERAND (t, 1));
6863
6864     case COND_EXPR:
6865       return integer_valued_real_p (TREE_OPERAND (t, 1))
6866              && integer_valued_real_p (TREE_OPERAND (t, 2));
6867
6868     case REAL_CST:
6869       return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
6870
6871     case NOP_EXPR:
6872       {
6873         tree type = TREE_TYPE (TREE_OPERAND (t, 0));
6874         if (TREE_CODE (type) == INTEGER_TYPE)
6875           return true;
6876         if (TREE_CODE (type) == REAL_TYPE)
6877           return integer_valued_real_p (TREE_OPERAND (t, 0));
6878         break;
6879       }
6880
6881     case CALL_EXPR:
6882       switch (builtin_mathfn_code (t))
6883         {
6884         CASE_FLT_FN (BUILT_IN_CEIL):
6885         CASE_FLT_FN (BUILT_IN_FLOOR):
6886         CASE_FLT_FN (BUILT_IN_NEARBYINT):
6887         CASE_FLT_FN (BUILT_IN_RINT):
6888         CASE_FLT_FN (BUILT_IN_ROUND):
6889         CASE_FLT_FN (BUILT_IN_TRUNC):
6890           return true;
6891
6892         CASE_FLT_FN (BUILT_IN_FMIN):
6893         CASE_FLT_FN (BUILT_IN_FMAX):
6894           return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
6895             && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
6896
6897         default:
6898           break;
6899         }
6900       break;
6901
6902     default:
6903       break;
6904     }
6905   return false;
6906 }
6907
6908 /* FNDECL is assumed to be a builtin where truncation can be propagated
6909    across (for instance floor((double)f) == (double)floorf (f).
6910    Do the transformation for a call with argument ARG.  */
6911
6912 static tree
6913 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
6914 {
6915   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6916
6917   if (!validate_arg (arg, REAL_TYPE))
6918     return NULL_TREE;
6919
6920   /* Integer rounding functions are idempotent.  */
6921   if (fcode == builtin_mathfn_code (arg))
6922     return arg;
6923
6924   /* If argument is already integer valued, and we don't need to worry
6925      about setting errno, there's no need to perform rounding.  */
6926   if (! flag_errno_math && integer_valued_real_p (arg))
6927     return arg;
6928
6929   if (optimize)
6930     {
6931       tree arg0 = strip_float_extensions (arg);
6932       tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
6933       tree newtype = TREE_TYPE (arg0);
6934       tree decl;
6935
6936       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6937           && (decl = mathfn_built_in (newtype, fcode)))
6938         return fold_convert_loc (loc, ftype,
6939                                  build_call_expr_loc (loc, decl, 1,
6940                                                   fold_convert_loc (loc,
6941                                                                     newtype,
6942                                                                     arg0)));
6943     }
6944   return NULL_TREE;
6945 }
6946
6947 /* FNDECL is assumed to be builtin which can narrow the FP type of
6948    the argument, for instance lround((double)f) -> lroundf (f).
6949    Do the transformation for a call with argument ARG.  */
6950
6951 static tree
6952 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
6953 {
6954   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6955
6956   if (!validate_arg (arg, REAL_TYPE))
6957     return NULL_TREE;
6958
6959   /* If argument is already integer valued, and we don't need to worry
6960      about setting errno, there's no need to perform rounding.  */
6961   if (! flag_errno_math && integer_valued_real_p (arg))
6962     return fold_build1_loc (loc, FIX_TRUNC_EXPR,
6963                         TREE_TYPE (TREE_TYPE (fndecl)), arg);
6964
6965   if (optimize)
6966     {
6967       tree ftype = TREE_TYPE (arg);
6968       tree arg0 = strip_float_extensions (arg);
6969       tree newtype = TREE_TYPE (arg0);
6970       tree decl;
6971
6972       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6973           && (decl = mathfn_built_in (newtype, fcode)))
6974         return build_call_expr_loc (loc, decl, 1,
6975                                 fold_convert_loc (loc, newtype, arg0));
6976     }
6977
6978   /* Canonicalize llround (x) to lround (x) on LP64 targets where
6979      sizeof (long long) == sizeof (long).  */
6980   if (TYPE_PRECISION (long_long_integer_type_node)
6981       == TYPE_PRECISION (long_integer_type_node))
6982     {
6983       tree newfn = NULL_TREE;
6984       switch (fcode)
6985         {
6986         CASE_FLT_FN (BUILT_IN_LLCEIL):
6987           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
6988           break;
6989
6990         CASE_FLT_FN (BUILT_IN_LLFLOOR):
6991           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
6992           break;
6993
6994         CASE_FLT_FN (BUILT_IN_LLROUND):
6995           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
6996           break;
6997
6998         CASE_FLT_FN (BUILT_IN_LLRINT):
6999           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7000           break;
7001
7002         default:
7003           break;
7004         }
7005
7006       if (newfn)
7007         {
7008           tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7009           return fold_convert_loc (loc,
7010                                    TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7011         }
7012     }
7013
7014   return NULL_TREE;
7015 }
7016
7017 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG.  TYPE is the
7018    return type.  Return NULL_TREE if no simplification can be made.  */
7019
7020 static tree
7021 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7022 {
7023   tree res;
7024
7025   if (!validate_arg (arg, COMPLEX_TYPE)
7026       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7027     return NULL_TREE;
7028
7029   /* Calculate the result when the argument is a constant.  */
7030   if (TREE_CODE (arg) == COMPLEX_CST
7031       && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7032                               type, mpfr_hypot)))
7033     return res;
7034
7035   if (TREE_CODE (arg) == COMPLEX_EXPR)
7036     {
7037       tree real = TREE_OPERAND (arg, 0);
7038       tree imag = TREE_OPERAND (arg, 1);
7039
7040       /* If either part is zero, cabs is fabs of the other.  */
7041       if (real_zerop (real))
7042         return fold_build1_loc (loc, ABS_EXPR, type, imag);
7043       if (real_zerop (imag))
7044         return fold_build1_loc (loc, ABS_EXPR, type, real);
7045
7046       /* cabs(x+xi) -> fabs(x)*sqrt(2).  */
7047       if (flag_unsafe_math_optimizations
7048           && operand_equal_p (real, imag, OEP_PURE_SAME))
7049         {
7050           const REAL_VALUE_TYPE sqrt2_trunc
7051             = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7052           STRIP_NOPS (real);
7053           return fold_build2_loc (loc, MULT_EXPR, type,
7054                               fold_build1_loc (loc, ABS_EXPR, type, real),
7055                               build_real (type, sqrt2_trunc));
7056         }
7057     }
7058
7059   /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z).  */
7060   if (TREE_CODE (arg) == NEGATE_EXPR
7061       || TREE_CODE (arg) == CONJ_EXPR)
7062     return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7063
7064   /* Don't do this when optimizing for size.  */
7065   if (flag_unsafe_math_optimizations
7066       && optimize && optimize_function_for_speed_p (cfun))
7067     {
7068       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7069
7070       if (sqrtfn != NULL_TREE)
7071         {
7072           tree rpart, ipart, result;
7073
7074           arg = builtin_save_expr (arg);
7075
7076           rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7077           ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7078
7079           rpart = builtin_save_expr (rpart);
7080           ipart = builtin_save_expr (ipart);
7081
7082           result = fold_build2_loc (loc, PLUS_EXPR, type,
7083                                 fold_build2_loc (loc, MULT_EXPR, type,
7084                                              rpart, rpart),
7085                                 fold_build2_loc (loc, MULT_EXPR, type,
7086                                              ipart, ipart));
7087
7088           return build_call_expr_loc (loc, sqrtfn, 1, result);
7089         }
7090     }
7091
7092   return NULL_TREE;
7093 }
7094
7095 /* Build a complex (inf +- 0i) for the result of cproj.  TYPE is the
7096    complex tree type of the result.  If NEG is true, the imaginary
7097    zero is negative.  */
7098
7099 static tree
7100 build_complex_cproj (tree type, bool neg)
7101 {
7102   REAL_VALUE_TYPE rinf, rzero = dconst0;
7103
7104   real_inf (&rinf);
7105   rzero.sign = neg;
7106   return build_complex (type, build_real (TREE_TYPE (type), rinf),
7107                         build_real (TREE_TYPE (type), rzero));
7108 }
7109
7110 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG.  TYPE is the
7111    return type.  Return NULL_TREE if no simplification can be made.  */
7112
7113 static tree
7114 fold_builtin_cproj (location_t loc, tree arg, tree type)
7115 {
7116   if (!validate_arg (arg, COMPLEX_TYPE)
7117       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7118     return NULL_TREE;
7119
7120   /* If there are no infinities, return arg.  */
7121   if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type))))
7122     return non_lvalue_loc (loc, arg);
7123
7124   /* Calculate the result when the argument is a constant.  */
7125   if (TREE_CODE (arg) == COMPLEX_CST)
7126     {
7127       const REAL_VALUE_TYPE *real = TREE_REAL_CST_PTR (TREE_REALPART (arg));
7128       const REAL_VALUE_TYPE *imag = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
7129
7130       if (real_isinf (real) || real_isinf (imag))
7131         return build_complex_cproj (type, imag->sign);
7132       else
7133         return arg;
7134     }
7135   else if (TREE_CODE (arg) == COMPLEX_EXPR)
7136     {
7137       tree real = TREE_OPERAND (arg, 0);
7138       tree imag = TREE_OPERAND (arg, 1);
7139
7140       STRIP_NOPS (real);
7141       STRIP_NOPS (imag);
7142
7143       /* If the real part is inf and the imag part is known to be
7144          nonnegative, return (inf + 0i).  Remember side-effects are
7145          possible in the imag part.  */
7146       if (TREE_CODE (real) == REAL_CST
7147           && real_isinf (TREE_REAL_CST_PTR (real))
7148           && tree_expr_nonnegative_p (imag))
7149         return omit_one_operand_loc (loc, type,
7150                                      build_complex_cproj (type, false),
7151                                      arg);
7152
7153       /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7154          Remember side-effects are possible in the real part.  */
7155       if (TREE_CODE (imag) == REAL_CST
7156           && real_isinf (TREE_REAL_CST_PTR (imag)))
7157         return
7158           omit_one_operand_loc (loc, type,
7159                                 build_complex_cproj (type, TREE_REAL_CST_PTR
7160                                                      (imag)->sign), arg);
7161     }
7162
7163   return NULL_TREE;
7164 }
7165
7166 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7167    Return NULL_TREE if no simplification can be made.  */
7168
7169 static tree
7170 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7171 {
7172
7173   enum built_in_function fcode;
7174   tree res;
7175
7176   if (!validate_arg (arg, REAL_TYPE))
7177     return NULL_TREE;
7178
7179   /* Calculate the result when the argument is a constant.  */
7180   if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7181     return res;
7182
7183   /* Optimize sqrt(expN(x)) = expN(x*0.5).  */
7184   fcode = builtin_mathfn_code (arg);
7185   if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7186     {
7187       tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7188       arg = fold_build2_loc (loc, MULT_EXPR, type,
7189                          CALL_EXPR_ARG (arg, 0),
7190                          build_real (type, dconsthalf));
7191       return build_call_expr_loc (loc, expfn, 1, arg);
7192     }
7193
7194   /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)).  */
7195   if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7196     {
7197       tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7198
7199       if (powfn)
7200         {
7201           tree arg0 = CALL_EXPR_ARG (arg, 0);
7202           tree tree_root;
7203           /* The inner root was either sqrt or cbrt.  */
7204           /* This was a conditional expression but it triggered a bug
7205              in Sun C 5.5.  */
7206           REAL_VALUE_TYPE dconstroot;
7207           if (BUILTIN_SQRT_P (fcode))
7208             dconstroot = dconsthalf;
7209           else
7210             dconstroot = dconst_third ();
7211
7212           /* Adjust for the outer root.  */
7213           SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7214           dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7215           tree_root = build_real (type, dconstroot);
7216           return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7217         }
7218     }
7219
7220   /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5).  */
7221   if (flag_unsafe_math_optimizations
7222       && (fcode == BUILT_IN_POW
7223           || fcode == BUILT_IN_POWF
7224           || fcode == BUILT_IN_POWL))
7225     {
7226       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7227       tree arg0 = CALL_EXPR_ARG (arg, 0);
7228       tree arg1 = CALL_EXPR_ARG (arg, 1);
7229       tree narg1;
7230       if (!tree_expr_nonnegative_p (arg0))
7231         arg0 = build1 (ABS_EXPR, type, arg0);
7232       narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7233                            build_real (type, dconsthalf));
7234       return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7235     }
7236
7237   return NULL_TREE;
7238 }
7239
7240 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7241    Return NULL_TREE if no simplification can be made.  */
7242
7243 static tree
7244 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7245 {
7246   const enum built_in_function fcode = builtin_mathfn_code (arg);
7247   tree res;
7248
7249   if (!validate_arg (arg, REAL_TYPE))
7250     return NULL_TREE;
7251
7252   /* Calculate the result when the argument is a constant.  */
7253   if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7254     return res;
7255
7256   if (flag_unsafe_math_optimizations)
7257     {
7258       /* Optimize cbrt(expN(x)) -> expN(x/3).  */
7259       if (BUILTIN_EXPONENT_P (fcode))
7260         {
7261           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7262           const REAL_VALUE_TYPE third_trunc =
7263             real_value_truncate (TYPE_MODE (type), dconst_third ());
7264           arg = fold_build2_loc (loc, MULT_EXPR, type,
7265                              CALL_EXPR_ARG (arg, 0),
7266                              build_real (type, third_trunc));
7267           return build_call_expr_loc (loc, expfn, 1, arg);
7268         }
7269
7270       /* Optimize cbrt(sqrt(x)) -> pow(x,1/6).  */
7271       if (BUILTIN_SQRT_P (fcode))
7272         {
7273           tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7274
7275           if (powfn)
7276             {
7277               tree arg0 = CALL_EXPR_ARG (arg, 0);
7278               tree tree_root;
7279               REAL_VALUE_TYPE dconstroot = dconst_third ();
7280
7281               SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7282               dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7283               tree_root = build_real (type, dconstroot);
7284               return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7285             }
7286         }
7287
7288       /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative.  */
7289       if (BUILTIN_CBRT_P (fcode))
7290         {
7291           tree arg0 = CALL_EXPR_ARG (arg, 0);
7292           if (tree_expr_nonnegative_p (arg0))
7293             {
7294               tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7295
7296               if (powfn)
7297                 {
7298                   tree tree_root;
7299                   REAL_VALUE_TYPE dconstroot;
7300
7301                   real_arithmetic (&dconstroot, MULT_EXPR,
7302                                    dconst_third_ptr (), dconst_third_ptr ());
7303                   dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7304                   tree_root = build_real (type, dconstroot);
7305                   return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7306                 }
7307             }
7308         }
7309
7310       /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative.  */
7311       if (fcode == BUILT_IN_POW
7312           || fcode == BUILT_IN_POWF
7313           || fcode == BUILT_IN_POWL)
7314         {
7315           tree arg00 = CALL_EXPR_ARG (arg, 0);
7316           tree arg01 = CALL_EXPR_ARG (arg, 1);
7317           if (tree_expr_nonnegative_p (arg00))
7318             {
7319               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7320               const REAL_VALUE_TYPE dconstroot
7321                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7322               tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7323                                          build_real (type, dconstroot));
7324               return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7325             }
7326         }
7327     }
7328   return NULL_TREE;
7329 }
7330
7331 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7332    TYPE is the type of the return value.  Return NULL_TREE if no
7333    simplification can be made.  */
7334
7335 static tree
7336 fold_builtin_cos (location_t loc,
7337                   tree arg, tree type, tree fndecl)
7338 {
7339   tree res, narg;
7340
7341   if (!validate_arg (arg, REAL_TYPE))
7342     return NULL_TREE;
7343
7344   /* Calculate the result when the argument is a constant.  */
7345   if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7346     return res;
7347
7348   /* Optimize cos(-x) into cos (x).  */
7349   if ((narg = fold_strip_sign_ops (arg)))
7350     return build_call_expr_loc (loc, fndecl, 1, narg);
7351
7352   return NULL_TREE;
7353 }
7354
7355 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7356    Return NULL_TREE if no simplification can be made.  */
7357
7358 static tree
7359 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7360 {
7361   if (validate_arg (arg, REAL_TYPE))
7362     {
7363       tree res, narg;
7364
7365       /* Calculate the result when the argument is a constant.  */
7366       if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7367         return res;
7368
7369       /* Optimize cosh(-x) into cosh (x).  */
7370       if ((narg = fold_strip_sign_ops (arg)))
7371         return build_call_expr_loc (loc, fndecl, 1, narg);
7372     }
7373
7374   return NULL_TREE;
7375 }
7376
7377 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7378    argument ARG.  TYPE is the type of the return value.  Return
7379    NULL_TREE if no simplification can be made.  */
7380
7381 static tree
7382 fold_builtin_ccos (location_t loc, tree arg, tree type, tree fndecl,
7383                    bool hyper)
7384 {
7385   if (validate_arg (arg, COMPLEX_TYPE)
7386       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7387     {
7388       tree tmp;
7389
7390       /* Calculate the result when the argument is a constant.  */
7391       if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7392         return tmp;
7393
7394       /* Optimize fn(-x) into fn(x).  */
7395       if ((tmp = fold_strip_sign_ops (arg)))
7396         return build_call_expr_loc (loc, fndecl, 1, tmp);
7397     }
7398
7399   return NULL_TREE;
7400 }
7401
7402 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7403    Return NULL_TREE if no simplification can be made.  */
7404
7405 static tree
7406 fold_builtin_tan (tree arg, tree type)
7407 {
7408   enum built_in_function fcode;
7409   tree res;
7410
7411   if (!validate_arg (arg, REAL_TYPE))
7412     return NULL_TREE;
7413
7414   /* Calculate the result when the argument is a constant.  */
7415   if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7416     return res;
7417
7418   /* Optimize tan(atan(x)) = x.  */
7419   fcode = builtin_mathfn_code (arg);
7420   if (flag_unsafe_math_optimizations
7421       && (fcode == BUILT_IN_ATAN
7422           || fcode == BUILT_IN_ATANF
7423           || fcode == BUILT_IN_ATANL))
7424     return CALL_EXPR_ARG (arg, 0);
7425
7426   return NULL_TREE;
7427 }
7428
7429 /* Fold function call to builtin sincos, sincosf, or sincosl.  Return
7430    NULL_TREE if no simplification can be made.  */
7431
7432 static tree
7433 fold_builtin_sincos (location_t loc,
7434                      tree arg0, tree arg1, tree arg2)
7435 {
7436   tree type;
7437   tree res, fn, call;
7438
7439   if (!validate_arg (arg0, REAL_TYPE)
7440       || !validate_arg (arg1, POINTER_TYPE)
7441       || !validate_arg (arg2, POINTER_TYPE))
7442     return NULL_TREE;
7443
7444   type = TREE_TYPE (arg0);
7445
7446   /* Calculate the result when the argument is a constant.  */
7447   if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7448     return res;
7449
7450   /* Canonicalize sincos to cexpi.  */
7451   if (!TARGET_C99_FUNCTIONS)
7452     return NULL_TREE;
7453   fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7454   if (!fn)
7455     return NULL_TREE;
7456
7457   call = build_call_expr_loc (loc, fn, 1, arg0);
7458   call = builtin_save_expr (call);
7459
7460   return build2 (COMPOUND_EXPR, void_type_node,
7461                  build2 (MODIFY_EXPR, void_type_node,
7462                          build_fold_indirect_ref_loc (loc, arg1),
7463                          build1 (IMAGPART_EXPR, type, call)),
7464                  build2 (MODIFY_EXPR, void_type_node,
7465                          build_fold_indirect_ref_loc (loc, arg2),
7466                          build1 (REALPART_EXPR, type, call)));
7467 }
7468
7469 /* Fold function call to builtin cexp, cexpf, or cexpl.  Return
7470    NULL_TREE if no simplification can be made.  */
7471
7472 static tree
7473 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7474 {
7475   tree rtype;
7476   tree realp, imagp, ifn;
7477   tree res;
7478
7479   if (!validate_arg (arg0, COMPLEX_TYPE)
7480       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7481     return NULL_TREE;
7482
7483   /* Calculate the result when the argument is a constant.  */
7484   if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7485     return res;
7486
7487   rtype = TREE_TYPE (TREE_TYPE (arg0));
7488
7489   /* In case we can figure out the real part of arg0 and it is constant zero
7490      fold to cexpi.  */
7491   if (!TARGET_C99_FUNCTIONS)
7492     return NULL_TREE;
7493   ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7494   if (!ifn)
7495     return NULL_TREE;
7496
7497   if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7498       && real_zerop (realp))
7499     {
7500       tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7501       return build_call_expr_loc (loc, ifn, 1, narg);
7502     }
7503
7504   /* In case we can easily decompose real and imaginary parts split cexp
7505      to exp (r) * cexpi (i).  */
7506   if (flag_unsafe_math_optimizations
7507       && realp)
7508     {
7509       tree rfn, rcall, icall;
7510
7511       rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7512       if (!rfn)
7513         return NULL_TREE;
7514
7515       imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7516       if (!imagp)
7517         return NULL_TREE;
7518
7519       icall = build_call_expr_loc (loc, ifn, 1, imagp);
7520       icall = builtin_save_expr (icall);
7521       rcall = build_call_expr_loc (loc, rfn, 1, realp);
7522       rcall = builtin_save_expr (rcall);
7523       return fold_build2_loc (loc, COMPLEX_EXPR, type,
7524                           fold_build2_loc (loc, MULT_EXPR, rtype,
7525                                        rcall,
7526                                        fold_build1_loc (loc, REALPART_EXPR,
7527                                                     rtype, icall)),
7528                           fold_build2_loc (loc, MULT_EXPR, rtype,
7529                                        rcall,
7530                                        fold_build1_loc (loc, IMAGPART_EXPR,
7531                                                     rtype, icall)));
7532     }
7533
7534   return NULL_TREE;
7535 }
7536
7537 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7538    Return NULL_TREE if no simplification can be made.  */
7539
7540 static tree
7541 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7542 {
7543   if (!validate_arg (arg, REAL_TYPE))
7544     return NULL_TREE;
7545
7546   /* Optimize trunc of constant value.  */
7547   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7548     {
7549       REAL_VALUE_TYPE r, x;
7550       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7551
7552       x = TREE_REAL_CST (arg);
7553       real_trunc (&r, TYPE_MODE (type), &x);
7554       return build_real (type, r);
7555     }
7556
7557   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7558 }
7559
7560 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7561    Return NULL_TREE if no simplification can be made.  */
7562
7563 static tree
7564 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7565 {
7566   if (!validate_arg (arg, REAL_TYPE))
7567     return NULL_TREE;
7568
7569   /* Optimize floor of constant value.  */
7570   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7571     {
7572       REAL_VALUE_TYPE x;
7573
7574       x = TREE_REAL_CST (arg);
7575       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7576         {
7577           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7578           REAL_VALUE_TYPE r;
7579
7580           real_floor (&r, TYPE_MODE (type), &x);
7581           return build_real (type, r);
7582         }
7583     }
7584
7585   /* Fold floor (x) where x is nonnegative to trunc (x).  */
7586   if (tree_expr_nonnegative_p (arg))
7587     {
7588       tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7589       if (truncfn)
7590         return build_call_expr_loc (loc, truncfn, 1, arg);
7591     }
7592
7593   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7594 }
7595
7596 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7597    Return NULL_TREE if no simplification can be made.  */
7598
7599 static tree
7600 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7601 {
7602   if (!validate_arg (arg, REAL_TYPE))
7603     return NULL_TREE;
7604
7605   /* Optimize ceil of constant value.  */
7606   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7607     {
7608       REAL_VALUE_TYPE x;
7609
7610       x = TREE_REAL_CST (arg);
7611       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7612         {
7613           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7614           REAL_VALUE_TYPE r;
7615
7616           real_ceil (&r, TYPE_MODE (type), &x);
7617           return build_real (type, r);
7618         }
7619     }
7620
7621   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7622 }
7623
7624 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7625    Return NULL_TREE if no simplification can be made.  */
7626
7627 static tree
7628 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7629 {
7630   if (!validate_arg (arg, REAL_TYPE))
7631     return NULL_TREE;
7632
7633   /* Optimize round of constant value.  */
7634   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7635     {
7636       REAL_VALUE_TYPE x;
7637
7638       x = TREE_REAL_CST (arg);
7639       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7640         {
7641           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7642           REAL_VALUE_TYPE r;
7643
7644           real_round (&r, TYPE_MODE (type), &x);
7645           return build_real (type, r);
7646         }
7647     }
7648
7649   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7650 }
7651
7652 /* Fold function call to builtin lround, lroundf or lroundl (or the
7653    corresponding long long versions) and other rounding functions.  ARG
7654    is the argument to the call.  Return NULL_TREE if no simplification
7655    can be made.  */
7656
7657 static tree
7658 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7659 {
7660   if (!validate_arg (arg, REAL_TYPE))
7661     return NULL_TREE;
7662
7663   /* Optimize lround of constant value.  */
7664   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7665     {
7666       const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7667
7668       if (real_isfinite (&x))
7669         {
7670           tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7671           tree ftype = TREE_TYPE (arg);
7672           double_int val;
7673           REAL_VALUE_TYPE r;
7674
7675           switch (DECL_FUNCTION_CODE (fndecl))
7676             {
7677             CASE_FLT_FN (BUILT_IN_LFLOOR):
7678             CASE_FLT_FN (BUILT_IN_LLFLOOR):
7679               real_floor (&r, TYPE_MODE (ftype), &x);
7680               break;
7681
7682             CASE_FLT_FN (BUILT_IN_LCEIL):
7683             CASE_FLT_FN (BUILT_IN_LLCEIL):
7684               real_ceil (&r, TYPE_MODE (ftype), &x);
7685               break;
7686
7687             CASE_FLT_FN (BUILT_IN_LROUND):
7688             CASE_FLT_FN (BUILT_IN_LLROUND):
7689               real_round (&r, TYPE_MODE (ftype), &x);
7690               break;
7691
7692             default:
7693               gcc_unreachable ();
7694             }
7695
7696           real_to_integer2 ((HOST_WIDE_INT *)&val.low, &val.high, &r);
7697           if (double_int_fits_to_tree_p (itype, val))
7698             return double_int_to_tree (itype, val);
7699         }
7700     }
7701
7702   switch (DECL_FUNCTION_CODE (fndecl))
7703     {
7704     CASE_FLT_FN (BUILT_IN_LFLOOR):
7705     CASE_FLT_FN (BUILT_IN_LLFLOOR):
7706       /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x).  */
7707       if (tree_expr_nonnegative_p (arg))
7708         return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7709                             TREE_TYPE (TREE_TYPE (fndecl)), arg);
7710       break;
7711     default:;
7712     }
7713
7714   return fold_fixed_mathfn (loc, fndecl, arg);
7715 }
7716
7717 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7718    and their long and long long variants (i.e. ffsl and ffsll).  ARG is
7719    the argument to the call.  Return NULL_TREE if no simplification can
7720    be made.  */
7721
7722 static tree
7723 fold_builtin_bitop (tree fndecl, tree arg)
7724 {
7725   if (!validate_arg (arg, INTEGER_TYPE))
7726     return NULL_TREE;
7727
7728   /* Optimize for constant argument.  */
7729   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7730     {
7731       HOST_WIDE_INT hi, width, result;
7732       unsigned HOST_WIDE_INT lo;
7733       tree type;
7734
7735       type = TREE_TYPE (arg);
7736       width = TYPE_PRECISION (type);
7737       lo = TREE_INT_CST_LOW (arg);
7738
7739       /* Clear all the bits that are beyond the type's precision.  */
7740       if (width > HOST_BITS_PER_WIDE_INT)
7741         {
7742           hi = TREE_INT_CST_HIGH (arg);
7743           if (width < 2 * HOST_BITS_PER_WIDE_INT)
7744             hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7745         }
7746       else
7747         {
7748           hi = 0;
7749           if (width < HOST_BITS_PER_WIDE_INT)
7750             lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7751         }
7752
7753       switch (DECL_FUNCTION_CODE (fndecl))
7754         {
7755         CASE_INT_FN (BUILT_IN_FFS):
7756           if (lo != 0)
7757             result = ffs_hwi (lo);
7758           else if (hi != 0)
7759             result = HOST_BITS_PER_WIDE_INT + ffs_hwi (hi);
7760           else
7761             result = 0;
7762           break;
7763
7764         CASE_INT_FN (BUILT_IN_CLZ):
7765           if (hi != 0)
7766             result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7767           else if (lo != 0)
7768             result = width - floor_log2 (lo) - 1;
7769           else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7770             result = width;
7771           break;
7772
7773         CASE_INT_FN (BUILT_IN_CTZ):
7774           if (lo != 0)
7775             result = ctz_hwi (lo);
7776           else if (hi != 0)
7777             result = HOST_BITS_PER_WIDE_INT + ctz_hwi (hi);
7778           else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7779             result = width;
7780           break;
7781
7782         CASE_INT_FN (BUILT_IN_POPCOUNT):
7783           result = 0;
7784           while (lo)
7785             result++, lo &= lo - 1;
7786           while (hi)
7787             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7788           break;
7789
7790         CASE_INT_FN (BUILT_IN_PARITY):
7791           result = 0;
7792           while (lo)
7793             result++, lo &= lo - 1;
7794           while (hi)
7795             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7796           result &= 1;
7797           break;
7798
7799         default:
7800           gcc_unreachable ();
7801         }
7802
7803       return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7804     }
7805
7806   return NULL_TREE;
7807 }
7808
7809 /* Fold function call to builtin_bswap and the long and long long
7810    variants.  Return NULL_TREE if no simplification can be made.  */
7811 static tree
7812 fold_builtin_bswap (tree fndecl, tree arg)
7813 {
7814   if (! validate_arg (arg, INTEGER_TYPE))
7815     return NULL_TREE;
7816
7817   /* Optimize constant value.  */
7818   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7819     {
7820       HOST_WIDE_INT hi, width, r_hi = 0;
7821       unsigned HOST_WIDE_INT lo, r_lo = 0;
7822       tree type;
7823
7824       type = TREE_TYPE (arg);
7825       width = TYPE_PRECISION (type);
7826       lo = TREE_INT_CST_LOW (arg);
7827       hi = TREE_INT_CST_HIGH (arg);
7828
7829       switch (DECL_FUNCTION_CODE (fndecl))
7830         {
7831           case BUILT_IN_BSWAP32:
7832           case BUILT_IN_BSWAP64:
7833             {
7834               int s;
7835
7836               for (s = 0; s < width; s += 8)
7837                 {
7838                   int d = width - s - 8;
7839                   unsigned HOST_WIDE_INT byte;
7840
7841                   if (s < HOST_BITS_PER_WIDE_INT)
7842                     byte = (lo >> s) & 0xff;
7843                   else
7844                     byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
7845
7846                   if (d < HOST_BITS_PER_WIDE_INT)
7847                     r_lo |= byte << d;
7848                   else
7849                     r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
7850                 }
7851             }
7852
7853             break;
7854
7855         default:
7856           gcc_unreachable ();
7857         }
7858
7859       if (width < HOST_BITS_PER_WIDE_INT)
7860         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
7861       else
7862         return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
7863     }
7864
7865   return NULL_TREE;
7866 }
7867
7868 /* A subroutine of fold_builtin to fold the various logarithmic
7869    functions.  Return NULL_TREE if no simplification can me made.
7870    FUNC is the corresponding MPFR logarithm function.  */
7871
7872 static tree
7873 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
7874                         int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
7875 {
7876   if (validate_arg (arg, REAL_TYPE))
7877     {
7878       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7879       tree res;
7880       const enum built_in_function fcode = builtin_mathfn_code (arg);
7881
7882       /* Calculate the result when the argument is a constant.  */
7883       if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
7884         return res;
7885
7886       /* Special case, optimize logN(expN(x)) = x.  */
7887       if (flag_unsafe_math_optimizations
7888           && ((func == mpfr_log
7889                && (fcode == BUILT_IN_EXP
7890                    || fcode == BUILT_IN_EXPF
7891                    || fcode == BUILT_IN_EXPL))
7892               || (func == mpfr_log2
7893                   && (fcode == BUILT_IN_EXP2
7894                       || fcode == BUILT_IN_EXP2F
7895                       || fcode == BUILT_IN_EXP2L))
7896               || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
7897         return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
7898
7899       /* Optimize logN(func()) for various exponential functions.  We
7900          want to determine the value "x" and the power "exponent" in
7901          order to transform logN(x**exponent) into exponent*logN(x).  */
7902       if (flag_unsafe_math_optimizations)
7903         {
7904           tree exponent = 0, x = 0;
7905
7906           switch (fcode)
7907           {
7908           CASE_FLT_FN (BUILT_IN_EXP):
7909             /* Prepare to do logN(exp(exponent) -> exponent*logN(e).  */
7910             x = build_real (type, real_value_truncate (TYPE_MODE (type),
7911                                                        dconst_e ()));
7912             exponent = CALL_EXPR_ARG (arg, 0);
7913             break;
7914           CASE_FLT_FN (BUILT_IN_EXP2):
7915             /* Prepare to do logN(exp2(exponent) -> exponent*logN(2).  */
7916             x = build_real (type, dconst2);
7917             exponent = CALL_EXPR_ARG (arg, 0);
7918             break;
7919           CASE_FLT_FN (BUILT_IN_EXP10):
7920           CASE_FLT_FN (BUILT_IN_POW10):
7921             /* Prepare to do logN(exp10(exponent) -> exponent*logN(10).  */
7922             {
7923               REAL_VALUE_TYPE dconst10;
7924               real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
7925               x = build_real (type, dconst10);
7926             }
7927             exponent = CALL_EXPR_ARG (arg, 0);
7928             break;
7929           CASE_FLT_FN (BUILT_IN_SQRT):
7930             /* Prepare to do logN(sqrt(x) -> 0.5*logN(x).  */
7931             x = CALL_EXPR_ARG (arg, 0);
7932             exponent = build_real (type, dconsthalf);
7933             break;
7934           CASE_FLT_FN (BUILT_IN_CBRT):
7935             /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x).  */
7936             x = CALL_EXPR_ARG (arg, 0);
7937             exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
7938                                                               dconst_third ()));
7939             break;
7940           CASE_FLT_FN (BUILT_IN_POW):
7941             /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x).  */
7942             x = CALL_EXPR_ARG (arg, 0);
7943             exponent = CALL_EXPR_ARG (arg, 1);
7944             break;
7945           default:
7946             break;
7947           }
7948
7949           /* Now perform the optimization.  */
7950           if (x && exponent)
7951             {
7952               tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
7953               return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
7954             }
7955         }
7956     }
7957
7958   return NULL_TREE;
7959 }
7960
7961 /* Fold a builtin function call to hypot, hypotf, or hypotl.  Return
7962    NULL_TREE if no simplification can be made.  */
7963
7964 static tree
7965 fold_builtin_hypot (location_t loc, tree fndecl,
7966                     tree arg0, tree arg1, tree type)
7967 {
7968   tree res, narg0, narg1;
7969
7970   if (!validate_arg (arg0, REAL_TYPE)
7971       || !validate_arg (arg1, REAL_TYPE))
7972     return NULL_TREE;
7973
7974   /* Calculate the result when the argument is a constant.  */
7975   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
7976     return res;
7977
7978   /* If either argument to hypot has a negate or abs, strip that off.
7979      E.g. hypot(-x,fabs(y)) -> hypot(x,y).  */
7980   narg0 = fold_strip_sign_ops (arg0);
7981   narg1 = fold_strip_sign_ops (arg1);
7982   if (narg0 || narg1)
7983     {
7984       return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
7985                               narg1 ? narg1 : arg1);
7986     }
7987
7988   /* If either argument is zero, hypot is fabs of the other.  */
7989   if (real_zerop (arg0))
7990     return fold_build1_loc (loc, ABS_EXPR, type, arg1);
7991   else if (real_zerop (arg1))
7992     return fold_build1_loc (loc, ABS_EXPR, type, arg0);
7993
7994   /* hypot(x,x) -> fabs(x)*sqrt(2).  */
7995   if (flag_unsafe_math_optimizations
7996       && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
7997     {
7998       const REAL_VALUE_TYPE sqrt2_trunc
7999         = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
8000       return fold_build2_loc (loc, MULT_EXPR, type,
8001                           fold_build1_loc (loc, ABS_EXPR, type, arg0),
8002                           build_real (type, sqrt2_trunc));
8003     }
8004
8005   return NULL_TREE;
8006 }
8007
8008
8009 /* Fold a builtin function call to pow, powf, or powl.  Return
8010    NULL_TREE if no simplification can be made.  */
8011 static tree
8012 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
8013 {
8014   tree res;
8015
8016   if (!validate_arg (arg0, REAL_TYPE)
8017        || !validate_arg (arg1, REAL_TYPE))
8018     return NULL_TREE;
8019
8020   /* Calculate the result when the argument is a constant.  */
8021   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8022     return res;
8023
8024   /* Optimize pow(1.0,y) = 1.0.  */
8025   if (real_onep (arg0))
8026     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8027
8028   if (TREE_CODE (arg1) == REAL_CST
8029       && !TREE_OVERFLOW (arg1))
8030     {
8031       REAL_VALUE_TYPE cint;
8032       REAL_VALUE_TYPE c;
8033       HOST_WIDE_INT n;
8034
8035       c = TREE_REAL_CST (arg1);
8036
8037       /* Optimize pow(x,0.0) = 1.0.  */
8038       if (REAL_VALUES_EQUAL (c, dconst0))
8039         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8040                                  arg0);
8041
8042       /* Optimize pow(x,1.0) = x.  */
8043       if (REAL_VALUES_EQUAL (c, dconst1))
8044         return arg0;
8045
8046       /* Optimize pow(x,-1.0) = 1.0/x.  */
8047       if (REAL_VALUES_EQUAL (c, dconstm1))
8048         return fold_build2_loc (loc, RDIV_EXPR, type,
8049                             build_real (type, dconst1), arg0);
8050
8051       /* Optimize pow(x,0.5) = sqrt(x).  */
8052       if (flag_unsafe_math_optimizations
8053           && REAL_VALUES_EQUAL (c, dconsthalf))
8054         {
8055           tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8056
8057           if (sqrtfn != NULL_TREE)
8058             return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8059         }
8060
8061       /* Optimize pow(x,1.0/3.0) = cbrt(x).  */
8062       if (flag_unsafe_math_optimizations)
8063         {
8064           const REAL_VALUE_TYPE dconstroot
8065             = real_value_truncate (TYPE_MODE (type), dconst_third ());
8066
8067           if (REAL_VALUES_EQUAL (c, dconstroot))
8068             {
8069               tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8070               if (cbrtfn != NULL_TREE)
8071                 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8072             }
8073         }
8074
8075       /* Check for an integer exponent.  */
8076       n = real_to_integer (&c);
8077       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8078       if (real_identical (&c, &cint))
8079         {
8080           /* Attempt to evaluate pow at compile-time, unless this should
8081              raise an exception.  */
8082           if (TREE_CODE (arg0) == REAL_CST
8083               && !TREE_OVERFLOW (arg0)
8084               && (n > 0
8085                   || (!flag_trapping_math && !flag_errno_math)
8086                   || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8087             {
8088               REAL_VALUE_TYPE x;
8089               bool inexact;
8090
8091               x = TREE_REAL_CST (arg0);
8092               inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8093               if (flag_unsafe_math_optimizations || !inexact)
8094                 return build_real (type, x);
8095             }
8096
8097           /* Strip sign ops from even integer powers.  */
8098           if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8099             {
8100               tree narg0 = fold_strip_sign_ops (arg0);
8101               if (narg0)
8102                 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8103             }
8104         }
8105     }
8106
8107   if (flag_unsafe_math_optimizations)
8108     {
8109       const enum built_in_function fcode = builtin_mathfn_code (arg0);
8110
8111       /* Optimize pow(expN(x),y) = expN(x*y).  */
8112       if (BUILTIN_EXPONENT_P (fcode))
8113         {
8114           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8115           tree arg = CALL_EXPR_ARG (arg0, 0);
8116           arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8117           return build_call_expr_loc (loc, expfn, 1, arg);
8118         }
8119
8120       /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
8121       if (BUILTIN_SQRT_P (fcode))
8122         {
8123           tree narg0 = CALL_EXPR_ARG (arg0, 0);
8124           tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8125                                     build_real (type, dconsthalf));
8126           return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8127         }
8128
8129       /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative.  */
8130       if (BUILTIN_CBRT_P (fcode))
8131         {
8132           tree arg = CALL_EXPR_ARG (arg0, 0);
8133           if (tree_expr_nonnegative_p (arg))
8134             {
8135               const REAL_VALUE_TYPE dconstroot
8136                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8137               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8138                                         build_real (type, dconstroot));
8139               return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8140             }
8141         }
8142
8143       /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative.  */
8144       if (fcode == BUILT_IN_POW
8145           || fcode == BUILT_IN_POWF
8146           || fcode == BUILT_IN_POWL)
8147         {
8148           tree arg00 = CALL_EXPR_ARG (arg0, 0);
8149           if (tree_expr_nonnegative_p (arg00))
8150             {
8151               tree arg01 = CALL_EXPR_ARG (arg0, 1);
8152               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8153               return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8154             }
8155         }
8156     }
8157
8158   return NULL_TREE;
8159 }
8160
8161 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8162    Return NULL_TREE if no simplification can be made.  */
8163 static tree
8164 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8165                    tree arg0, tree arg1, tree type)
8166 {
8167   if (!validate_arg (arg0, REAL_TYPE)
8168       || !validate_arg (arg1, INTEGER_TYPE))
8169     return NULL_TREE;
8170
8171   /* Optimize pow(1.0,y) = 1.0.  */
8172   if (real_onep (arg0))
8173     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8174
8175   if (host_integerp (arg1, 0))
8176     {
8177       HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8178
8179       /* Evaluate powi at compile-time.  */
8180       if (TREE_CODE (arg0) == REAL_CST
8181           && !TREE_OVERFLOW (arg0))
8182         {
8183           REAL_VALUE_TYPE x;
8184           x = TREE_REAL_CST (arg0);
8185           real_powi (&x, TYPE_MODE (type), &x, c);
8186           return build_real (type, x);
8187         }
8188
8189       /* Optimize pow(x,0) = 1.0.  */
8190       if (c == 0)
8191         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8192                                  arg0);
8193
8194       /* Optimize pow(x,1) = x.  */
8195       if (c == 1)
8196         return arg0;
8197
8198       /* Optimize pow(x,-1) = 1.0/x.  */
8199       if (c == -1)
8200         return fold_build2_loc (loc, RDIV_EXPR, type,
8201                            build_real (type, dconst1), arg0);
8202     }
8203
8204   return NULL_TREE;
8205 }
8206
8207 /* A subroutine of fold_builtin to fold the various exponent
8208    functions.  Return NULL_TREE if no simplification can be made.
8209    FUNC is the corresponding MPFR exponent function.  */
8210
8211 static tree
8212 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8213                        int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8214 {
8215   if (validate_arg (arg, REAL_TYPE))
8216     {
8217       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8218       tree res;
8219
8220       /* Calculate the result when the argument is a constant.  */
8221       if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8222         return res;
8223
8224       /* Optimize expN(logN(x)) = x.  */
8225       if (flag_unsafe_math_optimizations)
8226         {
8227           const enum built_in_function fcode = builtin_mathfn_code (arg);
8228
8229           if ((func == mpfr_exp
8230                && (fcode == BUILT_IN_LOG
8231                    || fcode == BUILT_IN_LOGF
8232                    || fcode == BUILT_IN_LOGL))
8233               || (func == mpfr_exp2
8234                   && (fcode == BUILT_IN_LOG2
8235                       || fcode == BUILT_IN_LOG2F
8236                       || fcode == BUILT_IN_LOG2L))
8237               || (func == mpfr_exp10
8238                   && (fcode == BUILT_IN_LOG10
8239                       || fcode == BUILT_IN_LOG10F
8240                       || fcode == BUILT_IN_LOG10L)))
8241             return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8242         }
8243     }
8244
8245   return NULL_TREE;
8246 }
8247
8248 /* Return true if VAR is a VAR_DECL or a component thereof.  */
8249
8250 static bool
8251 var_decl_component_p (tree var)
8252 {
8253   tree inner = var;
8254   while (handled_component_p (inner))
8255     inner = TREE_OPERAND (inner, 0);
8256   return SSA_VAR_P (inner);
8257 }
8258
8259 /* Fold function call to builtin memset.  Return
8260    NULL_TREE if no simplification can be made.  */
8261
8262 static tree
8263 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8264                      tree type, bool ignore)
8265 {
8266   tree var, ret, etype;
8267   unsigned HOST_WIDE_INT length, cval;
8268
8269   if (! validate_arg (dest, POINTER_TYPE)
8270       || ! validate_arg (c, INTEGER_TYPE)
8271       || ! validate_arg (len, INTEGER_TYPE))
8272     return NULL_TREE;
8273
8274   if (! host_integerp (len, 1))
8275     return NULL_TREE;
8276
8277   /* If the LEN parameter is zero, return DEST.  */
8278   if (integer_zerop (len))
8279     return omit_one_operand_loc (loc, type, dest, c);
8280
8281   if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
8282     return NULL_TREE;
8283
8284   var = dest;
8285   STRIP_NOPS (var);
8286   if (TREE_CODE (var) != ADDR_EXPR)
8287     return NULL_TREE;
8288
8289   var = TREE_OPERAND (var, 0);
8290   if (TREE_THIS_VOLATILE (var))
8291     return NULL_TREE;
8292
8293   etype = TREE_TYPE (var);
8294   if (TREE_CODE (etype) == ARRAY_TYPE)
8295     etype = TREE_TYPE (etype);
8296
8297   if (!INTEGRAL_TYPE_P (etype)
8298       && !POINTER_TYPE_P (etype))
8299     return NULL_TREE;
8300
8301   if (! var_decl_component_p (var))
8302     return NULL_TREE;
8303
8304   length = tree_low_cst (len, 1);
8305   if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8306       || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8307          < length)
8308     return NULL_TREE;
8309
8310   if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8311     return NULL_TREE;
8312
8313   if (integer_zerop (c))
8314     cval = 0;
8315   else
8316     {
8317       if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8318         return NULL_TREE;
8319
8320       cval = tree_low_cst (c, 1);
8321       cval &= 0xff;
8322       cval |= cval << 8;
8323       cval |= cval << 16;
8324       cval |= (cval << 31) << 1;
8325     }
8326
8327   ret = build_int_cst_type (etype, cval);
8328   var = build_fold_indirect_ref_loc (loc,
8329                                  fold_convert_loc (loc,
8330                                                    build_pointer_type (etype),
8331                                                    dest));
8332   ret = build2 (MODIFY_EXPR, etype, var, ret);
8333   if (ignore)
8334     return ret;
8335
8336   return omit_one_operand_loc (loc, type, dest, ret);
8337 }
8338
8339 /* Fold function call to builtin memset.  Return
8340    NULL_TREE if no simplification can be made.  */
8341
8342 static tree
8343 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8344 {
8345   if (! validate_arg (dest, POINTER_TYPE)
8346       || ! validate_arg (size, INTEGER_TYPE))
8347     return NULL_TREE;
8348
8349   if (!ignore)
8350     return NULL_TREE;
8351
8352   /* New argument list transforming bzero(ptr x, int y) to
8353      memset(ptr x, int 0, size_t y).   This is done this way
8354      so that if it isn't expanded inline, we fallback to
8355      calling bzero instead of memset.  */
8356
8357   return fold_builtin_memset (loc, dest, integer_zero_node,
8358                               fold_convert_loc (loc, sizetype, size),
8359                               void_type_node, ignore);
8360 }
8361
8362 /* Fold function call to builtin mem{{,p}cpy,move}.  Return
8363    NULL_TREE if no simplification can be made.
8364    If ENDP is 0, return DEST (like memcpy).
8365    If ENDP is 1, return DEST+LEN (like mempcpy).
8366    If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8367    If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8368    (memmove).   */
8369
8370 static tree
8371 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8372                         tree len, tree type, bool ignore, int endp)
8373 {
8374   tree destvar, srcvar, expr;
8375
8376   if (! validate_arg (dest, POINTER_TYPE)
8377       || ! validate_arg (src, POINTER_TYPE)
8378       || ! validate_arg (len, INTEGER_TYPE))
8379     return NULL_TREE;
8380
8381   /* If the LEN parameter is zero, return DEST.  */
8382   if (integer_zerop (len))
8383     return omit_one_operand_loc (loc, type, dest, src);
8384
8385   /* If SRC and DEST are the same (and not volatile), return
8386      DEST{,+LEN,+LEN-1}.  */
8387   if (operand_equal_p (src, dest, 0))
8388     expr = len;
8389   else
8390     {
8391       tree srctype, desttype;
8392       unsigned int src_align, dest_align;
8393       tree off0;
8394
8395       if (endp == 3)
8396         {
8397           src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8398           dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8399
8400           /* Both DEST and SRC must be pointer types.
8401              ??? This is what old code did.  Is the testing for pointer types
8402              really mandatory?
8403
8404              If either SRC is readonly or length is 1, we can use memcpy.  */
8405           if (!dest_align || !src_align)
8406             return NULL_TREE;
8407           if (readonly_data_expr (src)
8408               || (host_integerp (len, 1)
8409                   && (MIN (src_align, dest_align) / BITS_PER_UNIT
8410                       >= (unsigned HOST_WIDE_INT) tree_low_cst (len, 1))))
8411             {
8412               tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8413               if (!fn)
8414                 return NULL_TREE;
8415               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8416             }
8417
8418           /* If *src and *dest can't overlap, optimize into memcpy as well.  */
8419           if (TREE_CODE (src) == ADDR_EXPR
8420               && TREE_CODE (dest) == ADDR_EXPR)
8421             {
8422               tree src_base, dest_base, fn;
8423               HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8424               HOST_WIDE_INT size = -1;
8425               HOST_WIDE_INT maxsize = -1;
8426
8427               srcvar = TREE_OPERAND (src, 0);
8428               src_base = get_ref_base_and_extent (srcvar, &src_offset,
8429                                                   &size, &maxsize);
8430               destvar = TREE_OPERAND (dest, 0);
8431               dest_base = get_ref_base_and_extent (destvar, &dest_offset,
8432                                                    &size, &maxsize);
8433               if (host_integerp (len, 1))
8434                 maxsize = tree_low_cst (len, 1);
8435               else
8436                 maxsize = -1;
8437               src_offset /= BITS_PER_UNIT;
8438               dest_offset /= BITS_PER_UNIT;
8439               if (SSA_VAR_P (src_base)
8440                   && SSA_VAR_P (dest_base))
8441                 {
8442                   if (operand_equal_p (src_base, dest_base, 0)
8443                       && ranges_overlap_p (src_offset, maxsize,
8444                                            dest_offset, maxsize))
8445                     return NULL_TREE;
8446                 }
8447               else if (TREE_CODE (src_base) == MEM_REF
8448                        && TREE_CODE (dest_base) == MEM_REF)
8449                 {
8450                   double_int off;
8451                   if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8452                                          TREE_OPERAND (dest_base, 0), 0))
8453                     return NULL_TREE;
8454                   off = double_int_add (mem_ref_offset (src_base),
8455                                         shwi_to_double_int (src_offset));
8456                   if (!double_int_fits_in_shwi_p (off))
8457                     return NULL_TREE;
8458                   src_offset = off.low;
8459                   off = double_int_add (mem_ref_offset (dest_base),
8460                                         shwi_to_double_int (dest_offset));
8461                   if (!double_int_fits_in_shwi_p (off))
8462                     return NULL_TREE;
8463                   dest_offset = off.low;
8464                   if (ranges_overlap_p (src_offset, maxsize,
8465                                         dest_offset, maxsize))
8466                     return NULL_TREE;
8467                 }
8468               else
8469                 return NULL_TREE;
8470
8471               fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8472               if (!fn)
8473                 return NULL_TREE;
8474               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8475             }
8476
8477           /* If the destination and source do not alias optimize into
8478              memcpy as well.  */
8479           if ((is_gimple_min_invariant (dest)
8480                || TREE_CODE (dest) == SSA_NAME)
8481               && (is_gimple_min_invariant (src)
8482                   || TREE_CODE (src) == SSA_NAME))
8483             {
8484               ao_ref destr, srcr;
8485               ao_ref_init_from_ptr_and_size (&destr, dest, len);
8486               ao_ref_init_from_ptr_and_size (&srcr, src, len);
8487               if (!refs_may_alias_p_1 (&destr, &srcr, false))
8488                 {
8489                   tree fn;
8490                   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8491                   if (!fn)
8492                     return NULL_TREE;
8493                   return build_call_expr_loc (loc, fn, 3, dest, src, len);
8494                 }
8495             }
8496
8497           return NULL_TREE;
8498         }
8499
8500       if (!host_integerp (len, 0))
8501         return NULL_TREE;
8502       /* FIXME:
8503          This logic lose for arguments like (type *)malloc (sizeof (type)),
8504          since we strip the casts of up to VOID return value from malloc.
8505          Perhaps we ought to inherit type from non-VOID argument here?  */
8506       STRIP_NOPS (src);
8507       STRIP_NOPS (dest);
8508       /* As we fold (void *)(p + CST) to (void *)p + CST undo this here.  */
8509       if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8510         {
8511           tree tem = TREE_OPERAND (src, 0);
8512           STRIP_NOPS (tem);
8513           if (tem != TREE_OPERAND (src, 0))
8514             src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8515         }
8516       if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8517         {
8518           tree tem = TREE_OPERAND (dest, 0);
8519           STRIP_NOPS (tem);
8520           if (tem != TREE_OPERAND (dest, 0))
8521             dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8522         }
8523       srctype = TREE_TYPE (TREE_TYPE (src));
8524       if (srctype
8525           && TREE_CODE (srctype) == ARRAY_TYPE
8526           && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8527         {
8528           srctype = TREE_TYPE (srctype);
8529           STRIP_NOPS (src);
8530           src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8531         }
8532       desttype = TREE_TYPE (TREE_TYPE (dest));
8533       if (desttype
8534           && TREE_CODE (desttype) == ARRAY_TYPE
8535           && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8536         {
8537           desttype = TREE_TYPE (desttype);
8538           STRIP_NOPS (dest);
8539           dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8540         }
8541       if (!srctype || !desttype
8542           || TREE_ADDRESSABLE (srctype)
8543           || TREE_ADDRESSABLE (desttype)
8544           || !TYPE_SIZE_UNIT (srctype)
8545           || !TYPE_SIZE_UNIT (desttype)
8546           || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
8547           || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST)
8548         return NULL_TREE;
8549
8550       src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8551       dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8552       if (dest_align < TYPE_ALIGN (desttype)
8553           || src_align < TYPE_ALIGN (srctype))
8554         return NULL_TREE;
8555
8556       if (!ignore)
8557         dest = builtin_save_expr (dest);
8558
8559       /* Build accesses at offset zero with a ref-all character type.  */
8560       off0 = build_int_cst (build_pointer_type_for_mode (char_type_node,
8561                                                          ptr_mode, true), 0);
8562
8563       destvar = dest;
8564       STRIP_NOPS (destvar);
8565       if (TREE_CODE (destvar) == ADDR_EXPR
8566           && var_decl_component_p (TREE_OPERAND (destvar, 0))
8567           && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8568         destvar = fold_build2 (MEM_REF, desttype, destvar, off0);
8569       else
8570         destvar = NULL_TREE;
8571
8572       srcvar = src;
8573       STRIP_NOPS (srcvar);
8574       if (TREE_CODE (srcvar) == ADDR_EXPR
8575           && var_decl_component_p (TREE_OPERAND (srcvar, 0))
8576           && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len)
8577           && (!STRICT_ALIGNMENT
8578               || !destvar
8579               || src_align >= TYPE_ALIGN (desttype)))
8580         srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype,
8581                               srcvar, off0);
8582       else
8583         srcvar = NULL_TREE;
8584
8585       if (srcvar == NULL_TREE && destvar == NULL_TREE)
8586         return NULL_TREE;
8587
8588       if (srcvar == NULL_TREE)
8589         {
8590           if (STRICT_ALIGNMENT
8591               && src_align < TYPE_ALIGN (desttype))
8592             return NULL_TREE;
8593           STRIP_NOPS (src);
8594           srcvar = fold_build2 (MEM_REF, desttype, src, off0);
8595         }
8596       else if (destvar == NULL_TREE)
8597         {
8598           if (STRICT_ALIGNMENT
8599               && dest_align < TYPE_ALIGN (srctype))
8600             return NULL_TREE;
8601           STRIP_NOPS (dest);
8602           destvar = fold_build2 (MEM_REF, srctype, dest, off0);
8603         }
8604
8605       expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, srcvar);
8606     }
8607
8608   if (ignore)
8609     return expr;
8610
8611   if (endp == 0 || endp == 3)
8612     return omit_one_operand_loc (loc, type, dest, expr);
8613
8614   if (expr == len)
8615     expr = NULL_TREE;
8616
8617   if (endp == 2)
8618     len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
8619                        ssize_int (1));
8620
8621   len = fold_convert_loc (loc, sizetype, len);
8622   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8623   dest = fold_convert_loc (loc, type, dest);
8624   if (expr)
8625     dest = omit_one_operand_loc (loc, type, dest, expr);
8626   return dest;
8627 }
8628
8629 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8630    If LEN is not NULL, it represents the length of the string to be
8631    copied.  Return NULL_TREE if no simplification can be made.  */
8632
8633 tree
8634 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
8635 {
8636   tree fn;
8637
8638   if (!validate_arg (dest, POINTER_TYPE)
8639       || !validate_arg (src, POINTER_TYPE))
8640     return NULL_TREE;
8641
8642   /* If SRC and DEST are the same (and not volatile), return DEST.  */
8643   if (operand_equal_p (src, dest, 0))
8644     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
8645
8646   if (optimize_function_for_size_p (cfun))
8647     return NULL_TREE;
8648
8649   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8650   if (!fn)
8651     return NULL_TREE;
8652
8653   if (!len)
8654     {
8655       len = c_strlen (src, 1);
8656       if (! len || TREE_SIDE_EFFECTS (len))
8657         return NULL_TREE;
8658     }
8659
8660   len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8661   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8662                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8663 }
8664
8665 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
8666    Return NULL_TREE if no simplification can be made.  */
8667
8668 static tree
8669 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
8670 {
8671   tree fn, len, lenp1, call, type;
8672
8673   if (!validate_arg (dest, POINTER_TYPE)
8674       || !validate_arg (src, POINTER_TYPE))
8675     return NULL_TREE;
8676
8677   len = c_strlen (src, 1);
8678   if (!len
8679       || TREE_CODE (len) != INTEGER_CST)
8680     return NULL_TREE;
8681
8682   if (optimize_function_for_size_p (cfun)
8683       /* If length is zero it's small enough.  */
8684       && !integer_zerop (len))
8685     return NULL_TREE;
8686
8687   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8688   if (!fn)
8689     return NULL_TREE;
8690
8691   lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8692   /* We use dest twice in building our expression.  Save it from
8693      multiple expansions.  */
8694   dest = builtin_save_expr (dest);
8695   call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
8696
8697   type = TREE_TYPE (TREE_TYPE (fndecl));
8698   len = fold_convert_loc (loc, sizetype, len);
8699   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8700   dest = fold_convert_loc (loc, type, dest);
8701   dest = omit_one_operand_loc (loc, type, dest, call);
8702   return dest;
8703 }
8704
8705 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8706    If SLEN is not NULL, it represents the length of the source string.
8707    Return NULL_TREE if no simplification can be made.  */
8708
8709 tree
8710 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
8711                       tree src, tree len, tree slen)
8712 {
8713   tree fn;
8714
8715   if (!validate_arg (dest, POINTER_TYPE)
8716       || !validate_arg (src, POINTER_TYPE)
8717       || !validate_arg (len, INTEGER_TYPE))
8718     return NULL_TREE;
8719
8720   /* If the LEN parameter is zero, return DEST.  */
8721   if (integer_zerop (len))
8722     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8723
8724   /* We can't compare slen with len as constants below if len is not a
8725      constant.  */
8726   if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8727     return NULL_TREE;
8728
8729   if (!slen)
8730     slen = c_strlen (src, 1);
8731
8732   /* Now, we must be passed a constant src ptr parameter.  */
8733   if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8734     return NULL_TREE;
8735
8736   slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
8737
8738   /* We do not support simplification of this case, though we do
8739      support it when expanding trees into RTL.  */
8740   /* FIXME: generate a call to __builtin_memset.  */
8741   if (tree_int_cst_lt (slen, len))
8742     return NULL_TREE;
8743
8744   /* OK transform into builtin memcpy.  */
8745   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8746   if (!fn)
8747     return NULL_TREE;
8748   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8749                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8750 }
8751
8752 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
8753    arguments to the call, and TYPE is its return type.
8754    Return NULL_TREE if no simplification can be made.  */
8755
8756 static tree
8757 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
8758 {
8759   if (!validate_arg (arg1, POINTER_TYPE)
8760       || !validate_arg (arg2, INTEGER_TYPE)
8761       || !validate_arg (len, INTEGER_TYPE))
8762     return NULL_TREE;
8763   else
8764     {
8765       const char *p1;
8766
8767       if (TREE_CODE (arg2) != INTEGER_CST
8768           || !host_integerp (len, 1))
8769         return NULL_TREE;
8770
8771       p1 = c_getstr (arg1);
8772       if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
8773         {
8774           char c;
8775           const char *r;
8776           tree tem;
8777
8778           if (target_char_cast (arg2, &c))
8779             return NULL_TREE;
8780
8781           r = (char *) memchr (p1, c, tree_low_cst (len, 1));
8782
8783           if (r == NULL)
8784             return build_int_cst (TREE_TYPE (arg1), 0);
8785
8786           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
8787                              size_int (r - p1));
8788           return fold_convert_loc (loc, type, tem);
8789         }
8790       return NULL_TREE;
8791     }
8792 }
8793
8794 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8795    Return NULL_TREE if no simplification can be made.  */
8796
8797 static tree
8798 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
8799 {
8800   const char *p1, *p2;
8801
8802   if (!validate_arg (arg1, POINTER_TYPE)
8803       || !validate_arg (arg2, POINTER_TYPE)
8804       || !validate_arg (len, INTEGER_TYPE))
8805     return NULL_TREE;
8806
8807   /* If the LEN parameter is zero, return zero.  */
8808   if (integer_zerop (len))
8809     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8810                               arg1, arg2);
8811
8812   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8813   if (operand_equal_p (arg1, arg2, 0))
8814     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8815
8816   p1 = c_getstr (arg1);
8817   p2 = c_getstr (arg2);
8818
8819   /* If all arguments are constant, and the value of len is not greater
8820      than the lengths of arg1 and arg2, evaluate at compile-time.  */
8821   if (host_integerp (len, 1) && p1 && p2
8822       && compare_tree_int (len, strlen (p1) + 1) <= 0
8823       && compare_tree_int (len, strlen (p2) + 1) <= 0)
8824     {
8825       const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8826
8827       if (r > 0)
8828         return integer_one_node;
8829       else if (r < 0)
8830         return integer_minus_one_node;
8831       else
8832         return integer_zero_node;
8833     }
8834
8835   /* If len parameter is one, return an expression corresponding to
8836      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
8837   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8838     {
8839       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8840       tree cst_uchar_ptr_node
8841         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8842
8843       tree ind1
8844         = fold_convert_loc (loc, integer_type_node,
8845                             build1 (INDIRECT_REF, cst_uchar_node,
8846                                     fold_convert_loc (loc,
8847                                                       cst_uchar_ptr_node,
8848                                                       arg1)));
8849       tree ind2
8850         = fold_convert_loc (loc, integer_type_node,
8851                             build1 (INDIRECT_REF, cst_uchar_node,
8852                                     fold_convert_loc (loc,
8853                                                       cst_uchar_ptr_node,
8854                                                       arg2)));
8855       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8856     }
8857
8858   return NULL_TREE;
8859 }
8860
8861 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8862    Return NULL_TREE if no simplification can be made.  */
8863
8864 static tree
8865 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
8866 {
8867   const char *p1, *p2;
8868
8869   if (!validate_arg (arg1, POINTER_TYPE)
8870       || !validate_arg (arg2, POINTER_TYPE))
8871     return NULL_TREE;
8872
8873   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8874   if (operand_equal_p (arg1, arg2, 0))
8875     return integer_zero_node;
8876
8877   p1 = c_getstr (arg1);
8878   p2 = c_getstr (arg2);
8879
8880   if (p1 && p2)
8881     {
8882       const int i = strcmp (p1, p2);
8883       if (i < 0)
8884         return integer_minus_one_node;
8885       else if (i > 0)
8886         return integer_one_node;
8887       else
8888         return integer_zero_node;
8889     }
8890
8891   /* If the second arg is "", return *(const unsigned char*)arg1.  */
8892   if (p2 && *p2 == '\0')
8893     {
8894       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8895       tree cst_uchar_ptr_node
8896         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8897
8898       return fold_convert_loc (loc, integer_type_node,
8899                                build1 (INDIRECT_REF, cst_uchar_node,
8900                                        fold_convert_loc (loc,
8901                                                          cst_uchar_ptr_node,
8902                                                          arg1)));
8903     }
8904
8905   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
8906   if (p1 && *p1 == '\0')
8907     {
8908       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8909       tree cst_uchar_ptr_node
8910         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8911
8912       tree temp
8913         = fold_convert_loc (loc, integer_type_node,
8914                             build1 (INDIRECT_REF, cst_uchar_node,
8915                                     fold_convert_loc (loc,
8916                                                       cst_uchar_ptr_node,
8917                                                       arg2)));
8918       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8919     }
8920
8921   return NULL_TREE;
8922 }
8923
8924 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
8925    Return NULL_TREE if no simplification can be made.  */
8926
8927 static tree
8928 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
8929 {
8930   const char *p1, *p2;
8931
8932   if (!validate_arg (arg1, POINTER_TYPE)
8933       || !validate_arg (arg2, POINTER_TYPE)
8934       || !validate_arg (len, INTEGER_TYPE))
8935     return NULL_TREE;
8936
8937   /* If the LEN parameter is zero, return zero.  */
8938   if (integer_zerop (len))
8939     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8940                               arg1, arg2);
8941
8942   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8943   if (operand_equal_p (arg1, arg2, 0))
8944     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8945
8946   p1 = c_getstr (arg1);
8947   p2 = c_getstr (arg2);
8948
8949   if (host_integerp (len, 1) && p1 && p2)
8950     {
8951       const int i = strncmp (p1, p2, tree_low_cst (len, 1));
8952       if (i > 0)
8953         return integer_one_node;
8954       else if (i < 0)
8955         return integer_minus_one_node;
8956       else
8957         return integer_zero_node;
8958     }
8959
8960   /* If the second arg is "", and the length is greater than zero,
8961      return *(const unsigned char*)arg1.  */
8962   if (p2 && *p2 == '\0'
8963       && TREE_CODE (len) == INTEGER_CST
8964       && tree_int_cst_sgn (len) == 1)
8965     {
8966       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8967       tree cst_uchar_ptr_node
8968         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8969
8970       return fold_convert_loc (loc, integer_type_node,
8971                                build1 (INDIRECT_REF, cst_uchar_node,
8972                                        fold_convert_loc (loc,
8973                                                          cst_uchar_ptr_node,
8974                                                          arg1)));
8975     }
8976
8977   /* If the first arg is "", and the length is greater than zero,
8978      return -*(const unsigned char*)arg2.  */
8979   if (p1 && *p1 == '\0'
8980       && TREE_CODE (len) == INTEGER_CST
8981       && tree_int_cst_sgn (len) == 1)
8982     {
8983       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8984       tree cst_uchar_ptr_node
8985         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8986
8987       tree temp = fold_convert_loc (loc, integer_type_node,
8988                                     build1 (INDIRECT_REF, cst_uchar_node,
8989                                             fold_convert_loc (loc,
8990                                                               cst_uchar_ptr_node,
8991                                                               arg2)));
8992       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8993     }
8994
8995   /* If len parameter is one, return an expression corresponding to
8996      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
8997   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8998     {
8999       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9000       tree cst_uchar_ptr_node
9001         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9002
9003       tree ind1 = fold_convert_loc (loc, integer_type_node,
9004                                     build1 (INDIRECT_REF, cst_uchar_node,
9005                                             fold_convert_loc (loc,
9006                                                               cst_uchar_ptr_node,
9007                                                               arg1)));
9008       tree ind2 = fold_convert_loc (loc, integer_type_node,
9009                                     build1 (INDIRECT_REF, cst_uchar_node,
9010                                             fold_convert_loc (loc,
9011                                                               cst_uchar_ptr_node,
9012                                                               arg2)));
9013       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9014     }
9015
9016   return NULL_TREE;
9017 }
9018
9019 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9020    ARG.  Return NULL_TREE if no simplification can be made.  */
9021
9022 static tree
9023 fold_builtin_signbit (location_t loc, tree arg, tree type)
9024 {
9025   tree temp;
9026
9027   if (!validate_arg (arg, REAL_TYPE))
9028     return NULL_TREE;
9029
9030   /* If ARG is a compile-time constant, determine the result.  */
9031   if (TREE_CODE (arg) == REAL_CST
9032       && !TREE_OVERFLOW (arg))
9033     {
9034       REAL_VALUE_TYPE c;
9035
9036       c = TREE_REAL_CST (arg);
9037       temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
9038       return fold_convert_loc (loc, type, temp);
9039     }
9040
9041   /* If ARG is non-negative, the result is always zero.  */
9042   if (tree_expr_nonnegative_p (arg))
9043     return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9044
9045   /* If ARG's format doesn't have signed zeros, return "arg < 0.0".  */
9046   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9047     return fold_build2_loc (loc, LT_EXPR, type, arg,
9048                         build_real (TREE_TYPE (arg), dconst0));
9049
9050   return NULL_TREE;
9051 }
9052
9053 /* Fold function call to builtin copysign, copysignf or copysignl with
9054    arguments ARG1 and ARG2.  Return NULL_TREE if no simplification can
9055    be made.  */
9056
9057 static tree
9058 fold_builtin_copysign (location_t loc, tree fndecl,
9059                        tree arg1, tree arg2, tree type)
9060 {
9061   tree tem;
9062
9063   if (!validate_arg (arg1, REAL_TYPE)
9064       || !validate_arg (arg2, REAL_TYPE))
9065     return NULL_TREE;
9066
9067   /* copysign(X,X) is X.  */
9068   if (operand_equal_p (arg1, arg2, 0))
9069     return fold_convert_loc (loc, type, arg1);
9070
9071   /* If ARG1 and ARG2 are compile-time constants, determine the result.  */
9072   if (TREE_CODE (arg1) == REAL_CST
9073       && TREE_CODE (arg2) == REAL_CST
9074       && !TREE_OVERFLOW (arg1)
9075       && !TREE_OVERFLOW (arg2))
9076     {
9077       REAL_VALUE_TYPE c1, c2;
9078
9079       c1 = TREE_REAL_CST (arg1);
9080       c2 = TREE_REAL_CST (arg2);
9081       /* c1.sign := c2.sign.  */
9082       real_copysign (&c1, &c2);
9083       return build_real (type, c1);
9084     }
9085
9086   /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9087      Remember to evaluate Y for side-effects.  */
9088   if (tree_expr_nonnegative_p (arg2))
9089     return omit_one_operand_loc (loc, type,
9090                              fold_build1_loc (loc, ABS_EXPR, type, arg1),
9091                              arg2);
9092
9093   /* Strip sign changing operations for the first argument.  */
9094   tem = fold_strip_sign_ops (arg1);
9095   if (tem)
9096     return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9097
9098   return NULL_TREE;
9099 }
9100
9101 /* Fold a call to builtin isascii with argument ARG.  */
9102
9103 static tree
9104 fold_builtin_isascii (location_t loc, tree arg)
9105 {
9106   if (!validate_arg (arg, INTEGER_TYPE))
9107     return NULL_TREE;
9108   else
9109     {
9110       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
9111       arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9112                          build_int_cst (NULL_TREE,
9113                                         ~ (unsigned HOST_WIDE_INT) 0x7f));
9114       return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9115                           arg, integer_zero_node);
9116     }
9117 }
9118
9119 /* Fold a call to builtin toascii with argument ARG.  */
9120
9121 static tree
9122 fold_builtin_toascii (location_t loc, tree arg)
9123 {
9124   if (!validate_arg (arg, INTEGER_TYPE))
9125     return NULL_TREE;
9126
9127   /* Transform toascii(c) -> (c & 0x7f).  */
9128   return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9129                       build_int_cst (NULL_TREE, 0x7f));
9130 }
9131
9132 /* Fold a call to builtin isdigit with argument ARG.  */
9133
9134 static tree
9135 fold_builtin_isdigit (location_t loc, tree arg)
9136 {
9137   if (!validate_arg (arg, INTEGER_TYPE))
9138     return NULL_TREE;
9139   else
9140     {
9141       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
9142       /* According to the C standard, isdigit is unaffected by locale.
9143          However, it definitely is affected by the target character set.  */
9144       unsigned HOST_WIDE_INT target_digit0
9145         = lang_hooks.to_target_charset ('0');
9146
9147       if (target_digit0 == 0)
9148         return NULL_TREE;
9149
9150       arg = fold_convert_loc (loc, unsigned_type_node, arg);
9151       arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9152                          build_int_cst (unsigned_type_node, target_digit0));
9153       return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9154                           build_int_cst (unsigned_type_node, 9));
9155     }
9156 }
9157
9158 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
9159
9160 static tree
9161 fold_builtin_fabs (location_t loc, tree arg, tree type)
9162 {
9163   if (!validate_arg (arg, REAL_TYPE))
9164     return NULL_TREE;
9165
9166   arg = fold_convert_loc (loc, type, arg);
9167   if (TREE_CODE (arg) == REAL_CST)
9168     return fold_abs_const (arg, type);
9169   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9170 }
9171
9172 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
9173
9174 static tree
9175 fold_builtin_abs (location_t loc, tree arg, tree type)
9176 {
9177   if (!validate_arg (arg, INTEGER_TYPE))
9178     return NULL_TREE;
9179
9180   arg = fold_convert_loc (loc, type, arg);
9181   if (TREE_CODE (arg) == INTEGER_CST)
9182     return fold_abs_const (arg, type);
9183   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9184 }
9185
9186 /* Fold a call to builtin fmin or fmax.  */
9187
9188 static tree
9189 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9190                         tree type, bool max)
9191 {
9192   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9193     {
9194       /* Calculate the result when the argument is a constant.  */
9195       tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9196
9197       if (res)
9198         return res;
9199
9200       /* If either argument is NaN, return the other one.  Avoid the
9201          transformation if we get (and honor) a signalling NaN.  Using
9202          omit_one_operand() ensures we create a non-lvalue.  */
9203       if (TREE_CODE (arg0) == REAL_CST
9204           && real_isnan (&TREE_REAL_CST (arg0))
9205           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9206               || ! TREE_REAL_CST (arg0).signalling))
9207         return omit_one_operand_loc (loc, type, arg1, arg0);
9208       if (TREE_CODE (arg1) == REAL_CST
9209           && real_isnan (&TREE_REAL_CST (arg1))
9210           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9211               || ! TREE_REAL_CST (arg1).signalling))
9212         return omit_one_operand_loc (loc, type, arg0, arg1);
9213
9214       /* Transform fmin/fmax(x,x) -> x.  */
9215       if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9216         return omit_one_operand_loc (loc, type, arg0, arg1);
9217
9218       /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR.  C99 requires these
9219          functions to return the numeric arg if the other one is NaN.
9220          These tree codes don't honor that, so only transform if
9221          -ffinite-math-only is set.  C99 doesn't require -0.0 to be
9222          handled, so we don't have to worry about it either.  */
9223       if (flag_finite_math_only)
9224         return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9225                             fold_convert_loc (loc, type, arg0),
9226                             fold_convert_loc (loc, type, arg1));
9227     }
9228   return NULL_TREE;
9229 }
9230
9231 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
9232
9233 static tree
9234 fold_builtin_carg (location_t loc, tree arg, tree type)
9235 {
9236   if (validate_arg (arg, COMPLEX_TYPE)
9237       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9238     {
9239       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9240
9241       if (atan2_fn)
9242         {
9243           tree new_arg = builtin_save_expr (arg);
9244           tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9245           tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9246           return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9247         }
9248     }
9249
9250   return NULL_TREE;
9251 }
9252
9253 /* Fold a call to builtin logb/ilogb.  */
9254
9255 static tree
9256 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9257 {
9258   if (! validate_arg (arg, REAL_TYPE))
9259     return NULL_TREE;
9260
9261   STRIP_NOPS (arg);
9262
9263   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9264     {
9265       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9266
9267       switch (value->cl)
9268       {
9269       case rvc_nan:
9270       case rvc_inf:
9271         /* If arg is Inf or NaN and we're logb, return it.  */
9272         if (TREE_CODE (rettype) == REAL_TYPE)
9273           return fold_convert_loc (loc, rettype, arg);
9274         /* Fall through... */
9275       case rvc_zero:
9276         /* Zero may set errno and/or raise an exception for logb, also
9277            for ilogb we don't know FP_ILOGB0.  */
9278         return NULL_TREE;
9279       case rvc_normal:
9280         /* For normal numbers, proceed iff radix == 2.  In GCC,
9281            normalized significands are in the range [0.5, 1.0).  We
9282            want the exponent as if they were [1.0, 2.0) so get the
9283            exponent and subtract 1.  */
9284         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9285           return fold_convert_loc (loc, rettype,
9286                                    build_int_cst (NULL_TREE,
9287                                                   REAL_EXP (value)-1));
9288         break;
9289       }
9290     }
9291
9292   return NULL_TREE;
9293 }
9294
9295 /* Fold a call to builtin significand, if radix == 2.  */
9296
9297 static tree
9298 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9299 {
9300   if (! validate_arg (arg, REAL_TYPE))
9301     return NULL_TREE;
9302
9303   STRIP_NOPS (arg);
9304
9305   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9306     {
9307       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9308
9309       switch (value->cl)
9310       {
9311       case rvc_zero:
9312       case rvc_nan:
9313       case rvc_inf:
9314         /* If arg is +-0, +-Inf or +-NaN, then return it.  */
9315         return fold_convert_loc (loc, rettype, arg);
9316       case rvc_normal:
9317         /* For normal numbers, proceed iff radix == 2.  */
9318         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9319           {
9320             REAL_VALUE_TYPE result = *value;
9321             /* In GCC, normalized significands are in the range [0.5,
9322                1.0).  We want them to be [1.0, 2.0) so set the
9323                exponent to 1.  */
9324             SET_REAL_EXP (&result, 1);
9325             return build_real (rettype, result);
9326           }
9327         break;
9328       }
9329     }
9330
9331   return NULL_TREE;
9332 }
9333
9334 /* Fold a call to builtin frexp, we can assume the base is 2.  */
9335
9336 static tree
9337 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9338 {
9339   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9340     return NULL_TREE;
9341
9342   STRIP_NOPS (arg0);
9343
9344   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9345     return NULL_TREE;
9346
9347   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9348
9349   /* Proceed if a valid pointer type was passed in.  */
9350   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9351     {
9352       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9353       tree frac, exp;
9354
9355       switch (value->cl)
9356       {
9357       case rvc_zero:
9358         /* For +-0, return (*exp = 0, +-0).  */
9359         exp = integer_zero_node;
9360         frac = arg0;
9361         break;
9362       case rvc_nan:
9363       case rvc_inf:
9364         /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
9365         return omit_one_operand_loc (loc, rettype, arg0, arg1);
9366       case rvc_normal:
9367         {
9368           /* Since the frexp function always expects base 2, and in
9369              GCC normalized significands are already in the range
9370              [0.5, 1.0), we have exactly what frexp wants.  */
9371           REAL_VALUE_TYPE frac_rvt = *value;
9372           SET_REAL_EXP (&frac_rvt, 0);
9373           frac = build_real (rettype, frac_rvt);
9374           exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9375         }
9376         break;
9377       default:
9378         gcc_unreachable ();
9379       }
9380
9381       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9382       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9383       TREE_SIDE_EFFECTS (arg1) = 1;
9384       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9385     }
9386
9387   return NULL_TREE;
9388 }
9389
9390 /* Fold a call to builtin ldexp or scalbn/scalbln.  If LDEXP is true
9391    then we can assume the base is two.  If it's false, then we have to
9392    check the mode of the TYPE parameter in certain cases.  */
9393
9394 static tree
9395 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9396                             tree type, bool ldexp)
9397 {
9398   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9399     {
9400       STRIP_NOPS (arg0);
9401       STRIP_NOPS (arg1);
9402
9403       /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0.  */
9404       if (real_zerop (arg0) || integer_zerop (arg1)
9405           || (TREE_CODE (arg0) == REAL_CST
9406               && !real_isfinite (&TREE_REAL_CST (arg0))))
9407         return omit_one_operand_loc (loc, type, arg0, arg1);
9408
9409       /* If both arguments are constant, then try to evaluate it.  */
9410       if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9411           && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9412           && host_integerp (arg1, 0))
9413         {
9414           /* Bound the maximum adjustment to twice the range of the
9415              mode's valid exponents.  Use abs to ensure the range is
9416              positive as a sanity check.  */
9417           const long max_exp_adj = 2 *
9418             labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9419                  - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9420
9421           /* Get the user-requested adjustment.  */
9422           const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9423
9424           /* The requested adjustment must be inside this range.  This
9425              is a preliminary cap to avoid things like overflow, we
9426              may still fail to compute the result for other reasons.  */
9427           if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9428             {
9429               REAL_VALUE_TYPE initial_result;
9430
9431               real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9432
9433               /* Ensure we didn't overflow.  */
9434               if (! real_isinf (&initial_result))
9435                 {
9436                   const REAL_VALUE_TYPE trunc_result
9437                     = real_value_truncate (TYPE_MODE (type), initial_result);
9438
9439                   /* Only proceed if the target mode can hold the
9440                      resulting value.  */
9441                   if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9442                     return build_real (type, trunc_result);
9443                 }
9444             }
9445         }
9446     }
9447
9448   return NULL_TREE;
9449 }
9450
9451 /* Fold a call to builtin modf.  */
9452
9453 static tree
9454 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9455 {
9456   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9457     return NULL_TREE;
9458
9459   STRIP_NOPS (arg0);
9460
9461   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9462     return NULL_TREE;
9463
9464   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9465
9466   /* Proceed if a valid pointer type was passed in.  */
9467   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9468     {
9469       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9470       REAL_VALUE_TYPE trunc, frac;
9471
9472       switch (value->cl)
9473       {
9474       case rvc_nan:
9475       case rvc_zero:
9476         /* For +-NaN or +-0, return (*arg1 = arg0, arg0).  */
9477         trunc = frac = *value;
9478         break;
9479       case rvc_inf:
9480         /* For +-Inf, return (*arg1 = arg0, +-0).  */
9481         frac = dconst0;
9482         frac.sign = value->sign;
9483         trunc = *value;
9484         break;
9485       case rvc_normal:
9486         /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)).  */
9487         real_trunc (&trunc, VOIDmode, value);
9488         real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9489         /* If the original number was negative and already
9490            integral, then the fractional part is -0.0.  */
9491         if (value->sign && frac.cl == rvc_zero)
9492           frac.sign = value->sign;
9493         break;
9494       }
9495
9496       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9497       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9498                           build_real (rettype, trunc));
9499       TREE_SIDE_EFFECTS (arg1) = 1;
9500       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9501                           build_real (rettype, frac));
9502     }
9503
9504   return NULL_TREE;
9505 }
9506
9507 /* Given a location LOC, an interclass builtin function decl FNDECL
9508    and its single argument ARG, return an folded expression computing
9509    the same, or NULL_TREE if we either couldn't or didn't want to fold
9510    (the latter happen if there's an RTL instruction available).  */
9511
9512 static tree
9513 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9514 {
9515   enum machine_mode mode;
9516
9517   if (!validate_arg (arg, REAL_TYPE))
9518     return NULL_TREE;
9519
9520   if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9521     return NULL_TREE;
9522
9523   mode = TYPE_MODE (TREE_TYPE (arg));
9524
9525   /* If there is no optab, try generic code.  */
9526   switch (DECL_FUNCTION_CODE (fndecl))
9527     {
9528       tree result;
9529
9530     CASE_FLT_FN (BUILT_IN_ISINF):
9531       {
9532         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
9533         tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
9534         tree const type = TREE_TYPE (arg);
9535         REAL_VALUE_TYPE r;
9536         char buf[128];
9537
9538         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9539         real_from_string (&r, buf);
9540         result = build_call_expr (isgr_fn, 2,
9541                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9542                                   build_real (type, r));
9543         return result;
9544       }
9545     CASE_FLT_FN (BUILT_IN_FINITE):
9546     case BUILT_IN_ISFINITE:
9547       {
9548         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
9549         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9550         tree const type = TREE_TYPE (arg);
9551         REAL_VALUE_TYPE r;
9552         char buf[128];
9553
9554         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9555         real_from_string (&r, buf);
9556         result = build_call_expr (isle_fn, 2,
9557                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9558                                   build_real (type, r));
9559         /*result = fold_build2_loc (loc, UNGT_EXPR,
9560                                   TREE_TYPE (TREE_TYPE (fndecl)),
9561                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9562                                   build_real (type, r));
9563         result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9564                                   TREE_TYPE (TREE_TYPE (fndecl)),
9565                                   result);*/
9566         return result;
9567       }
9568     case BUILT_IN_ISNORMAL:
9569       {
9570         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9571            islessequal(fabs(x),DBL_MAX).  */
9572         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9573         tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
9574         tree const type = TREE_TYPE (arg);
9575         REAL_VALUE_TYPE rmax, rmin;
9576         char buf[128];
9577
9578         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9579         real_from_string (&rmax, buf);
9580         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9581         real_from_string (&rmin, buf);
9582         arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9583         result = build_call_expr (isle_fn, 2, arg,
9584                                   build_real (type, rmax));
9585         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
9586                               build_call_expr (isge_fn, 2, arg,
9587                                                build_real (type, rmin)));
9588         return result;
9589       }
9590     default:
9591       break;
9592     }
9593
9594   return NULL_TREE;
9595 }
9596
9597 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9598    ARG is the argument for the call.  */
9599
9600 static tree
9601 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
9602 {
9603   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9604   REAL_VALUE_TYPE r;
9605
9606   if (!validate_arg (arg, REAL_TYPE))
9607     return NULL_TREE;
9608
9609   switch (builtin_index)
9610     {
9611     case BUILT_IN_ISINF:
9612       if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9613         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9614
9615       if (TREE_CODE (arg) == REAL_CST)
9616         {
9617           r = TREE_REAL_CST (arg);
9618           if (real_isinf (&r))
9619             return real_compare (GT_EXPR, &r, &dconst0)
9620                    ? integer_one_node : integer_minus_one_node;
9621           else
9622             return integer_zero_node;
9623         }
9624
9625       return NULL_TREE;
9626
9627     case BUILT_IN_ISINF_SIGN:
9628       {
9629         /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9630         /* In a boolean context, GCC will fold the inner COND_EXPR to
9631            1.  So e.g. "if (isinf_sign(x))" would be folded to just
9632            "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9633         tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
9634         tree isinf_fn = built_in_decls[BUILT_IN_ISINF];
9635         tree tmp = NULL_TREE;
9636
9637         arg = builtin_save_expr (arg);
9638
9639         if (signbit_fn && isinf_fn)
9640           {
9641             tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
9642             tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
9643
9644             signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9645                                         signbit_call, integer_zero_node);
9646             isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9647                                       isinf_call, integer_zero_node);
9648
9649             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
9650                                integer_minus_one_node, integer_one_node);
9651             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9652                                isinf_call, tmp,
9653                                integer_zero_node);
9654           }
9655
9656         return tmp;
9657       }
9658
9659     case BUILT_IN_ISFINITE:
9660       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
9661           && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9662         return omit_one_operand_loc (loc, type, integer_one_node, arg);
9663
9664       if (TREE_CODE (arg) == REAL_CST)
9665         {
9666           r = TREE_REAL_CST (arg);
9667           return real_isfinite (&r) ? integer_one_node : integer_zero_node;
9668         }
9669
9670       return NULL_TREE;
9671
9672     case BUILT_IN_ISNAN:
9673       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
9674         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9675
9676       if (TREE_CODE (arg) == REAL_CST)
9677         {
9678           r = TREE_REAL_CST (arg);
9679           return real_isnan (&r) ? integer_one_node : integer_zero_node;
9680         }
9681
9682       arg = builtin_save_expr (arg);
9683       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
9684
9685     default:
9686       gcc_unreachable ();
9687     }
9688 }
9689
9690 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9691    This builtin will generate code to return the appropriate floating
9692    point classification depending on the value of the floating point
9693    number passed in.  The possible return values must be supplied as
9694    int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9695    FP_NORMAL, FP_SUBNORMAL and FP_ZERO.  The ellipses is for exactly
9696    one floating point argument which is "type generic".  */
9697
9698 static tree
9699 fold_builtin_fpclassify (location_t loc, tree exp)
9700 {
9701   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
9702     arg, type, res, tmp;
9703   enum machine_mode mode;
9704   REAL_VALUE_TYPE r;
9705   char buf[128];
9706
9707   /* Verify the required arguments in the original call.  */
9708   if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
9709                          INTEGER_TYPE, INTEGER_TYPE,
9710                          INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
9711     return NULL_TREE;
9712
9713   fp_nan = CALL_EXPR_ARG (exp, 0);
9714   fp_infinite = CALL_EXPR_ARG (exp, 1);
9715   fp_normal = CALL_EXPR_ARG (exp, 2);
9716   fp_subnormal = CALL_EXPR_ARG (exp, 3);
9717   fp_zero = CALL_EXPR_ARG (exp, 4);
9718   arg = CALL_EXPR_ARG (exp, 5);
9719   type = TREE_TYPE (arg);
9720   mode = TYPE_MODE (type);
9721   arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9722
9723   /* fpclassify(x) ->
9724        isnan(x) ? FP_NAN :
9725          (fabs(x) == Inf ? FP_INFINITE :
9726            (fabs(x) >= DBL_MIN ? FP_NORMAL :
9727              (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
9728
9729   tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9730                      build_real (type, dconst0));
9731   res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9732                      tmp, fp_zero, fp_subnormal);
9733
9734   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9735   real_from_string (&r, buf);
9736   tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
9737                      arg, build_real (type, r));
9738   res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
9739
9740   if (HONOR_INFINITIES (mode))
9741     {
9742       real_inf (&r);
9743       tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9744                          build_real (type, r));
9745       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
9746                          fp_infinite, res);
9747     }
9748
9749   if (HONOR_NANS (mode))
9750     {
9751       tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
9752       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
9753     }
9754
9755   return res;
9756 }
9757
9758 /* Fold a call to an unordered comparison function such as
9759    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
9760    being called and ARG0 and ARG1 are the arguments for the call.
9761    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9762    the opposite of the desired result.  UNORDERED_CODE is used
9763    for modes that can hold NaNs and ORDERED_CODE is used for
9764    the rest.  */
9765
9766 static tree
9767 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
9768                             enum tree_code unordered_code,
9769                             enum tree_code ordered_code)
9770 {
9771   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9772   enum tree_code code;
9773   tree type0, type1;
9774   enum tree_code code0, code1;
9775   tree cmp_type = NULL_TREE;
9776
9777   type0 = TREE_TYPE (arg0);
9778   type1 = TREE_TYPE (arg1);
9779
9780   code0 = TREE_CODE (type0);
9781   code1 = TREE_CODE (type1);
9782
9783   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
9784     /* Choose the wider of two real types.  */
9785     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
9786       ? type0 : type1;
9787   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
9788     cmp_type = type0;
9789   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
9790     cmp_type = type1;
9791
9792   arg0 = fold_convert_loc (loc, cmp_type, arg0);
9793   arg1 = fold_convert_loc (loc, cmp_type, arg1);
9794
9795   if (unordered_code == UNORDERED_EXPR)
9796     {
9797       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9798         return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
9799       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
9800     }
9801
9802   code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
9803                                                    : ordered_code;
9804   return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
9805                       fold_build2_loc (loc, code, type, arg0, arg1));
9806 }
9807
9808 /* Fold a call to built-in function FNDECL with 0 arguments.
9809    IGNORE is true if the result of the function call is ignored.  This
9810    function returns NULL_TREE if no simplification was possible.  */
9811
9812 static tree
9813 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
9814 {
9815   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9816   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9817   switch (fcode)
9818     {
9819     CASE_FLT_FN (BUILT_IN_INF):
9820     case BUILT_IN_INFD32:
9821     case BUILT_IN_INFD64:
9822     case BUILT_IN_INFD128:
9823       return fold_builtin_inf (loc, type, true);
9824
9825     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
9826       return fold_builtin_inf (loc, type, false);
9827
9828     case BUILT_IN_CLASSIFY_TYPE:
9829       return fold_builtin_classify_type (NULL_TREE);
9830
9831     default:
9832       break;
9833     }
9834   return NULL_TREE;
9835 }
9836
9837 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9838    IGNORE is true if the result of the function call is ignored.  This
9839    function returns NULL_TREE if no simplification was possible.  */
9840
9841 static tree
9842 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
9843 {
9844   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9845   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9846   switch (fcode)
9847     {
9848     case BUILT_IN_CONSTANT_P:
9849       {
9850         tree val = fold_builtin_constant_p (arg0);
9851
9852         /* Gimplification will pull the CALL_EXPR for the builtin out of
9853            an if condition.  When not optimizing, we'll not CSE it back.
9854            To avoid link error types of regressions, return false now.  */
9855         if (!val && !optimize)
9856           val = integer_zero_node;
9857
9858         return val;
9859       }
9860
9861     case BUILT_IN_CLASSIFY_TYPE:
9862       return fold_builtin_classify_type (arg0);
9863
9864     case BUILT_IN_STRLEN:
9865       return fold_builtin_strlen (loc, type, arg0);
9866
9867     CASE_FLT_FN (BUILT_IN_FABS):
9868       return fold_builtin_fabs (loc, arg0, type);
9869
9870     case BUILT_IN_ABS:
9871     case BUILT_IN_LABS:
9872     case BUILT_IN_LLABS:
9873     case BUILT_IN_IMAXABS:
9874       return fold_builtin_abs (loc, arg0, type);
9875
9876     CASE_FLT_FN (BUILT_IN_CONJ):
9877       if (validate_arg (arg0, COMPLEX_TYPE)
9878         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9879         return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
9880     break;
9881
9882     CASE_FLT_FN (BUILT_IN_CREAL):
9883       if (validate_arg (arg0, COMPLEX_TYPE)
9884         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9885         return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
9886     break;
9887
9888     CASE_FLT_FN (BUILT_IN_CIMAG):
9889       if (validate_arg (arg0, COMPLEX_TYPE)
9890           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9891         return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
9892     break;
9893
9894     CASE_FLT_FN (BUILT_IN_CCOS):
9895       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
9896
9897     CASE_FLT_FN (BUILT_IN_CCOSH):
9898       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
9899
9900     CASE_FLT_FN (BUILT_IN_CPROJ):
9901       return fold_builtin_cproj(loc, arg0, type);
9902
9903     CASE_FLT_FN (BUILT_IN_CSIN):
9904       if (validate_arg (arg0, COMPLEX_TYPE)
9905           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9906         return do_mpc_arg1 (arg0, type, mpc_sin);
9907     break;
9908
9909     CASE_FLT_FN (BUILT_IN_CSINH):
9910       if (validate_arg (arg0, COMPLEX_TYPE)
9911           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9912         return do_mpc_arg1 (arg0, type, mpc_sinh);
9913     break;
9914
9915     CASE_FLT_FN (BUILT_IN_CTAN):
9916       if (validate_arg (arg0, COMPLEX_TYPE)
9917           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9918         return do_mpc_arg1 (arg0, type, mpc_tan);
9919     break;
9920
9921     CASE_FLT_FN (BUILT_IN_CTANH):
9922       if (validate_arg (arg0, COMPLEX_TYPE)
9923           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9924         return do_mpc_arg1 (arg0, type, mpc_tanh);
9925     break;
9926
9927     CASE_FLT_FN (BUILT_IN_CLOG):
9928       if (validate_arg (arg0, COMPLEX_TYPE)
9929           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9930         return do_mpc_arg1 (arg0, type, mpc_log);
9931     break;
9932
9933     CASE_FLT_FN (BUILT_IN_CSQRT):
9934       if (validate_arg (arg0, COMPLEX_TYPE)
9935           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9936         return do_mpc_arg1 (arg0, type, mpc_sqrt);
9937     break;
9938
9939     CASE_FLT_FN (BUILT_IN_CASIN):
9940       if (validate_arg (arg0, COMPLEX_TYPE)
9941           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9942         return do_mpc_arg1 (arg0, type, mpc_asin);
9943     break;
9944
9945     CASE_FLT_FN (BUILT_IN_CACOS):
9946       if (validate_arg (arg0, COMPLEX_TYPE)
9947           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9948         return do_mpc_arg1 (arg0, type, mpc_acos);
9949     break;
9950
9951     CASE_FLT_FN (BUILT_IN_CATAN):
9952       if (validate_arg (arg0, COMPLEX_TYPE)
9953           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9954         return do_mpc_arg1 (arg0, type, mpc_atan);
9955     break;
9956
9957     CASE_FLT_FN (BUILT_IN_CASINH):
9958       if (validate_arg (arg0, COMPLEX_TYPE)
9959           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9960         return do_mpc_arg1 (arg0, type, mpc_asinh);
9961     break;
9962
9963     CASE_FLT_FN (BUILT_IN_CACOSH):
9964       if (validate_arg (arg0, COMPLEX_TYPE)
9965           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9966         return do_mpc_arg1 (arg0, type, mpc_acosh);
9967     break;
9968
9969     CASE_FLT_FN (BUILT_IN_CATANH):
9970       if (validate_arg (arg0, COMPLEX_TYPE)
9971           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9972         return do_mpc_arg1 (arg0, type, mpc_atanh);
9973     break;
9974
9975     CASE_FLT_FN (BUILT_IN_CABS):
9976       return fold_builtin_cabs (loc, arg0, type, fndecl);
9977
9978     CASE_FLT_FN (BUILT_IN_CARG):
9979       return fold_builtin_carg (loc, arg0, type);
9980
9981     CASE_FLT_FN (BUILT_IN_SQRT):
9982       return fold_builtin_sqrt (loc, arg0, type);
9983
9984     CASE_FLT_FN (BUILT_IN_CBRT):
9985       return fold_builtin_cbrt (loc, arg0, type);
9986
9987     CASE_FLT_FN (BUILT_IN_ASIN):
9988       if (validate_arg (arg0, REAL_TYPE))
9989         return do_mpfr_arg1 (arg0, type, mpfr_asin,
9990                              &dconstm1, &dconst1, true);
9991     break;
9992
9993     CASE_FLT_FN (BUILT_IN_ACOS):
9994       if (validate_arg (arg0, REAL_TYPE))
9995         return do_mpfr_arg1 (arg0, type, mpfr_acos,
9996                              &dconstm1, &dconst1, true);
9997     break;
9998
9999     CASE_FLT_FN (BUILT_IN_ATAN):
10000       if (validate_arg (arg0, REAL_TYPE))
10001         return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10002     break;
10003
10004     CASE_FLT_FN (BUILT_IN_ASINH):
10005       if (validate_arg (arg0, REAL_TYPE))
10006         return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10007     break;
10008
10009     CASE_FLT_FN (BUILT_IN_ACOSH):
10010       if (validate_arg (arg0, REAL_TYPE))
10011         return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10012                              &dconst1, NULL, true);
10013     break;
10014
10015     CASE_FLT_FN (BUILT_IN_ATANH):
10016       if (validate_arg (arg0, REAL_TYPE))
10017         return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10018                              &dconstm1, &dconst1, false);
10019     break;
10020
10021     CASE_FLT_FN (BUILT_IN_SIN):
10022       if (validate_arg (arg0, REAL_TYPE))
10023         return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10024     break;
10025
10026     CASE_FLT_FN (BUILT_IN_COS):
10027       return fold_builtin_cos (loc, arg0, type, fndecl);
10028
10029     CASE_FLT_FN (BUILT_IN_TAN):
10030       return fold_builtin_tan (arg0, type);
10031
10032     CASE_FLT_FN (BUILT_IN_CEXP):
10033       return fold_builtin_cexp (loc, arg0, type);
10034
10035     CASE_FLT_FN (BUILT_IN_CEXPI):
10036       if (validate_arg (arg0, REAL_TYPE))
10037         return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10038     break;
10039
10040     CASE_FLT_FN (BUILT_IN_SINH):
10041       if (validate_arg (arg0, REAL_TYPE))
10042         return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10043     break;
10044
10045     CASE_FLT_FN (BUILT_IN_COSH):
10046       return fold_builtin_cosh (loc, arg0, type, fndecl);
10047
10048     CASE_FLT_FN (BUILT_IN_TANH):
10049       if (validate_arg (arg0, REAL_TYPE))
10050         return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10051     break;
10052
10053     CASE_FLT_FN (BUILT_IN_ERF):
10054       if (validate_arg (arg0, REAL_TYPE))
10055         return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10056     break;
10057
10058     CASE_FLT_FN (BUILT_IN_ERFC):
10059       if (validate_arg (arg0, REAL_TYPE))
10060         return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10061     break;
10062
10063     CASE_FLT_FN (BUILT_IN_TGAMMA):
10064       if (validate_arg (arg0, REAL_TYPE))
10065         return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10066     break;
10067
10068     CASE_FLT_FN (BUILT_IN_EXP):
10069       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10070
10071     CASE_FLT_FN (BUILT_IN_EXP2):
10072       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10073
10074     CASE_FLT_FN (BUILT_IN_EXP10):
10075     CASE_FLT_FN (BUILT_IN_POW10):
10076       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10077
10078     CASE_FLT_FN (BUILT_IN_EXPM1):
10079       if (validate_arg (arg0, REAL_TYPE))
10080         return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10081     break;
10082
10083     CASE_FLT_FN (BUILT_IN_LOG):
10084     return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10085
10086     CASE_FLT_FN (BUILT_IN_LOG2):
10087       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10088
10089     CASE_FLT_FN (BUILT_IN_LOG10):
10090       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10091
10092     CASE_FLT_FN (BUILT_IN_LOG1P):
10093       if (validate_arg (arg0, REAL_TYPE))
10094         return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10095                              &dconstm1, NULL, false);
10096     break;
10097
10098     CASE_FLT_FN (BUILT_IN_J0):
10099       if (validate_arg (arg0, REAL_TYPE))
10100         return do_mpfr_arg1 (arg0, type, mpfr_j0,
10101                              NULL, NULL, 0);
10102     break;
10103
10104     CASE_FLT_FN (BUILT_IN_J1):
10105       if (validate_arg (arg0, REAL_TYPE))
10106         return do_mpfr_arg1 (arg0, type, mpfr_j1,
10107                              NULL, NULL, 0);
10108     break;
10109
10110     CASE_FLT_FN (BUILT_IN_Y0):
10111       if (validate_arg (arg0, REAL_TYPE))
10112         return do_mpfr_arg1 (arg0, type, mpfr_y0,
10113                              &dconst0, NULL, false);
10114     break;
10115
10116     CASE_FLT_FN (BUILT_IN_Y1):
10117       if (validate_arg (arg0, REAL_TYPE))
10118         return do_mpfr_arg1 (arg0, type, mpfr_y1,
10119                              &dconst0, NULL, false);
10120     break;
10121
10122     CASE_FLT_FN (BUILT_IN_NAN):
10123     case BUILT_IN_NAND32:
10124     case BUILT_IN_NAND64:
10125     case BUILT_IN_NAND128:
10126       return fold_builtin_nan (arg0, type, true);
10127
10128     CASE_FLT_FN (BUILT_IN_NANS):
10129       return fold_builtin_nan (arg0, type, false);
10130
10131     CASE_FLT_FN (BUILT_IN_FLOOR):
10132       return fold_builtin_floor (loc, fndecl, arg0);
10133
10134     CASE_FLT_FN (BUILT_IN_CEIL):
10135       return fold_builtin_ceil (loc, fndecl, arg0);
10136
10137     CASE_FLT_FN (BUILT_IN_TRUNC):
10138       return fold_builtin_trunc (loc, fndecl, arg0);
10139
10140     CASE_FLT_FN (BUILT_IN_ROUND):
10141       return fold_builtin_round (loc, fndecl, arg0);
10142
10143     CASE_FLT_FN (BUILT_IN_NEARBYINT):
10144     CASE_FLT_FN (BUILT_IN_RINT):
10145       return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10146
10147     CASE_FLT_FN (BUILT_IN_LCEIL):
10148     CASE_FLT_FN (BUILT_IN_LLCEIL):
10149     CASE_FLT_FN (BUILT_IN_LFLOOR):
10150     CASE_FLT_FN (BUILT_IN_LLFLOOR):
10151     CASE_FLT_FN (BUILT_IN_LROUND):
10152     CASE_FLT_FN (BUILT_IN_LLROUND):
10153       return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10154
10155     CASE_FLT_FN (BUILT_IN_LRINT):
10156     CASE_FLT_FN (BUILT_IN_LLRINT):
10157       return fold_fixed_mathfn (loc, fndecl, arg0);
10158
10159     case BUILT_IN_BSWAP32:
10160     case BUILT_IN_BSWAP64:
10161       return fold_builtin_bswap (fndecl, arg0);
10162
10163     CASE_INT_FN (BUILT_IN_FFS):
10164     CASE_INT_FN (BUILT_IN_CLZ):
10165     CASE_INT_FN (BUILT_IN_CTZ):
10166     CASE_INT_FN (BUILT_IN_POPCOUNT):
10167     CASE_INT_FN (BUILT_IN_PARITY):
10168       return fold_builtin_bitop (fndecl, arg0);
10169
10170     CASE_FLT_FN (BUILT_IN_SIGNBIT):
10171       return fold_builtin_signbit (loc, arg0, type);
10172
10173     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10174       return fold_builtin_significand (loc, arg0, type);
10175
10176     CASE_FLT_FN (BUILT_IN_ILOGB):
10177     CASE_FLT_FN (BUILT_IN_LOGB):
10178       return fold_builtin_logb (loc, arg0, type);
10179
10180     case BUILT_IN_ISASCII:
10181       return fold_builtin_isascii (loc, arg0);
10182
10183     case BUILT_IN_TOASCII:
10184       return fold_builtin_toascii (loc, arg0);
10185
10186     case BUILT_IN_ISDIGIT:
10187       return fold_builtin_isdigit (loc, arg0);
10188
10189     CASE_FLT_FN (BUILT_IN_FINITE):
10190     case BUILT_IN_FINITED32:
10191     case BUILT_IN_FINITED64:
10192     case BUILT_IN_FINITED128:
10193     case BUILT_IN_ISFINITE:
10194       {
10195         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10196         if (ret)
10197           return ret;
10198         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10199       }
10200
10201     CASE_FLT_FN (BUILT_IN_ISINF):
10202     case BUILT_IN_ISINFD32:
10203     case BUILT_IN_ISINFD64:
10204     case BUILT_IN_ISINFD128:
10205       {
10206         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10207         if (ret)
10208           return ret;
10209         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10210       }
10211
10212     case BUILT_IN_ISNORMAL:
10213       return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10214
10215     case BUILT_IN_ISINF_SIGN:
10216       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10217
10218     CASE_FLT_FN (BUILT_IN_ISNAN):
10219     case BUILT_IN_ISNAND32:
10220     case BUILT_IN_ISNAND64:
10221     case BUILT_IN_ISNAND128:
10222       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10223
10224     case BUILT_IN_PRINTF:
10225     case BUILT_IN_PRINTF_UNLOCKED:
10226     case BUILT_IN_VPRINTF:
10227       return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10228
10229     case BUILT_IN_FREE:
10230       if (integer_zerop (arg0))
10231         return build_empty_stmt (loc);
10232       break;
10233
10234     default:
10235       break;
10236     }
10237
10238   return NULL_TREE;
10239
10240 }
10241
10242 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10243    IGNORE is true if the result of the function call is ignored.  This
10244    function returns NULL_TREE if no simplification was possible.  */
10245
10246 static tree
10247 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10248 {
10249   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10250   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10251
10252   switch (fcode)
10253     {
10254     CASE_FLT_FN (BUILT_IN_JN):
10255       if (validate_arg (arg0, INTEGER_TYPE)
10256           && validate_arg (arg1, REAL_TYPE))
10257         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10258     break;
10259
10260     CASE_FLT_FN (BUILT_IN_YN):
10261       if (validate_arg (arg0, INTEGER_TYPE)
10262           && validate_arg (arg1, REAL_TYPE))
10263         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10264                                  &dconst0, false);
10265     break;
10266
10267     CASE_FLT_FN (BUILT_IN_DREM):
10268     CASE_FLT_FN (BUILT_IN_REMAINDER):
10269       if (validate_arg (arg0, REAL_TYPE)
10270           && validate_arg(arg1, REAL_TYPE))
10271         return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10272     break;
10273
10274     CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10275     CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10276       if (validate_arg (arg0, REAL_TYPE)
10277           && validate_arg(arg1, POINTER_TYPE))
10278         return do_mpfr_lgamma_r (arg0, arg1, type);
10279     break;
10280
10281     CASE_FLT_FN (BUILT_IN_ATAN2):
10282       if (validate_arg (arg0, REAL_TYPE)
10283           && validate_arg(arg1, REAL_TYPE))
10284         return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10285     break;
10286
10287     CASE_FLT_FN (BUILT_IN_FDIM):
10288       if (validate_arg (arg0, REAL_TYPE)
10289           && validate_arg(arg1, REAL_TYPE))
10290         return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10291     break;
10292
10293     CASE_FLT_FN (BUILT_IN_HYPOT):
10294       return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10295
10296     CASE_FLT_FN (BUILT_IN_CPOW):
10297       if (validate_arg (arg0, COMPLEX_TYPE)
10298           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10299           && validate_arg (arg1, COMPLEX_TYPE)
10300           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10301         return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10302     break;
10303
10304     CASE_FLT_FN (BUILT_IN_LDEXP):
10305       return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10306     CASE_FLT_FN (BUILT_IN_SCALBN):
10307     CASE_FLT_FN (BUILT_IN_SCALBLN):
10308       return fold_builtin_load_exponent (loc, arg0, arg1,
10309                                          type, /*ldexp=*/false);
10310
10311     CASE_FLT_FN (BUILT_IN_FREXP):
10312       return fold_builtin_frexp (loc, arg0, arg1, type);
10313
10314     CASE_FLT_FN (BUILT_IN_MODF):
10315       return fold_builtin_modf (loc, arg0, arg1, type);
10316
10317     case BUILT_IN_BZERO:
10318       return fold_builtin_bzero (loc, arg0, arg1, ignore);
10319
10320     case BUILT_IN_FPUTS:
10321       return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10322
10323     case BUILT_IN_FPUTS_UNLOCKED:
10324       return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10325
10326     case BUILT_IN_STRSTR:
10327       return fold_builtin_strstr (loc, arg0, arg1, type);
10328
10329     case BUILT_IN_STRCAT:
10330       return fold_builtin_strcat (loc, arg0, arg1);
10331
10332     case BUILT_IN_STRSPN:
10333       return fold_builtin_strspn (loc, arg0, arg1);
10334
10335     case BUILT_IN_STRCSPN:
10336       return fold_builtin_strcspn (loc, arg0, arg1);
10337
10338     case BUILT_IN_STRCHR:
10339     case BUILT_IN_INDEX:
10340       return fold_builtin_strchr (loc, arg0, arg1, type);
10341
10342     case BUILT_IN_STRRCHR:
10343     case BUILT_IN_RINDEX:
10344       return fold_builtin_strrchr (loc, arg0, arg1, type);
10345
10346     case BUILT_IN_STRCPY:
10347       return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10348
10349     case BUILT_IN_STPCPY:
10350       if (ignore)
10351         {
10352           tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
10353           if (!fn)
10354             break;
10355
10356           return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10357         }
10358       else
10359         return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10360       break;
10361
10362     case BUILT_IN_STRCMP:
10363       return fold_builtin_strcmp (loc, arg0, arg1);
10364
10365     case BUILT_IN_STRPBRK:
10366       return fold_builtin_strpbrk (loc, arg0, arg1, type);
10367
10368     case BUILT_IN_EXPECT:
10369       return fold_builtin_expect (loc, arg0, arg1);
10370
10371     CASE_FLT_FN (BUILT_IN_POW):
10372       return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10373
10374     CASE_FLT_FN (BUILT_IN_POWI):
10375       return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10376
10377     CASE_FLT_FN (BUILT_IN_COPYSIGN):
10378       return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10379
10380     CASE_FLT_FN (BUILT_IN_FMIN):
10381       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10382
10383     CASE_FLT_FN (BUILT_IN_FMAX):
10384       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10385
10386     case BUILT_IN_ISGREATER:
10387       return fold_builtin_unordered_cmp (loc, fndecl,
10388                                          arg0, arg1, UNLE_EXPR, LE_EXPR);
10389     case BUILT_IN_ISGREATEREQUAL:
10390       return fold_builtin_unordered_cmp (loc, fndecl,
10391                                          arg0, arg1, UNLT_EXPR, LT_EXPR);
10392     case BUILT_IN_ISLESS:
10393       return fold_builtin_unordered_cmp (loc, fndecl,
10394                                          arg0, arg1, UNGE_EXPR, GE_EXPR);
10395     case BUILT_IN_ISLESSEQUAL:
10396       return fold_builtin_unordered_cmp (loc, fndecl,
10397                                          arg0, arg1, UNGT_EXPR, GT_EXPR);
10398     case BUILT_IN_ISLESSGREATER:
10399       return fold_builtin_unordered_cmp (loc, fndecl,
10400                                          arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10401     case BUILT_IN_ISUNORDERED:
10402       return fold_builtin_unordered_cmp (loc, fndecl,
10403                                          arg0, arg1, UNORDERED_EXPR,
10404                                          NOP_EXPR);
10405
10406       /* We do the folding for va_start in the expander.  */
10407     case BUILT_IN_VA_START:
10408       break;
10409
10410     case BUILT_IN_SPRINTF:
10411       return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10412
10413     case BUILT_IN_OBJECT_SIZE:
10414       return fold_builtin_object_size (arg0, arg1);
10415
10416     case BUILT_IN_PRINTF:
10417     case BUILT_IN_PRINTF_UNLOCKED:
10418     case BUILT_IN_VPRINTF:
10419       return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10420
10421     case BUILT_IN_PRINTF_CHK:
10422     case BUILT_IN_VPRINTF_CHK:
10423       if (!validate_arg (arg0, INTEGER_TYPE)
10424           || TREE_SIDE_EFFECTS (arg0))
10425         return NULL_TREE;
10426       else
10427         return fold_builtin_printf (loc, fndecl,
10428                                     arg1, NULL_TREE, ignore, fcode);
10429     break;
10430
10431     case BUILT_IN_FPRINTF:
10432     case BUILT_IN_FPRINTF_UNLOCKED:
10433     case BUILT_IN_VFPRINTF:
10434       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10435                                    ignore, fcode);
10436
10437     default:
10438       break;
10439     }
10440   return NULL_TREE;
10441 }
10442
10443 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10444    and ARG2.  IGNORE is true if the result of the function call is ignored.
10445    This function returns NULL_TREE if no simplification was possible.  */
10446
10447 static tree
10448 fold_builtin_3 (location_t loc, tree fndecl,
10449                 tree arg0, tree arg1, tree arg2, bool ignore)
10450 {
10451   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10452   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10453   switch (fcode)
10454     {
10455
10456     CASE_FLT_FN (BUILT_IN_SINCOS):
10457       return fold_builtin_sincos (loc, arg0, arg1, arg2);
10458
10459     CASE_FLT_FN (BUILT_IN_FMA):
10460       if (validate_arg (arg0, REAL_TYPE)
10461           && validate_arg(arg1, REAL_TYPE)
10462           && validate_arg(arg2, REAL_TYPE))
10463         return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
10464     break;
10465
10466     CASE_FLT_FN (BUILT_IN_REMQUO):
10467       if (validate_arg (arg0, REAL_TYPE)
10468           && validate_arg(arg1, REAL_TYPE)
10469           && validate_arg(arg2, POINTER_TYPE))
10470         return do_mpfr_remquo (arg0, arg1, arg2);
10471     break;
10472
10473     case BUILT_IN_MEMSET:
10474       return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10475
10476     case BUILT_IN_BCOPY:
10477       return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10478                                      void_type_node, true, /*endp=*/3);
10479
10480     case BUILT_IN_MEMCPY:
10481       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10482                                      type, ignore, /*endp=*/0);
10483
10484     case BUILT_IN_MEMPCPY:
10485       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10486                                      type, ignore, /*endp=*/1);
10487
10488     case BUILT_IN_MEMMOVE:
10489       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10490                                      type, ignore, /*endp=*/3);
10491
10492     case BUILT_IN_STRNCAT:
10493       return fold_builtin_strncat (loc, arg0, arg1, arg2);
10494
10495     case BUILT_IN_STRNCPY:
10496       return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10497
10498     case BUILT_IN_STRNCMP:
10499       return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10500
10501     case BUILT_IN_MEMCHR:
10502       return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10503
10504     case BUILT_IN_BCMP:
10505     case BUILT_IN_MEMCMP:
10506       return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10507
10508     case BUILT_IN_SPRINTF:
10509       return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10510
10511     case BUILT_IN_STRCPY_CHK:
10512     case BUILT_IN_STPCPY_CHK:
10513       return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10514                                       ignore, fcode);
10515
10516     case BUILT_IN_STRCAT_CHK:
10517       return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10518
10519     case BUILT_IN_PRINTF_CHK:
10520     case BUILT_IN_VPRINTF_CHK:
10521       if (!validate_arg (arg0, INTEGER_TYPE)
10522           || TREE_SIDE_EFFECTS (arg0))
10523         return NULL_TREE;
10524       else
10525         return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10526     break;
10527
10528     case BUILT_IN_FPRINTF:
10529     case BUILT_IN_FPRINTF_UNLOCKED:
10530     case BUILT_IN_VFPRINTF:
10531       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10532                                    ignore, fcode);
10533
10534     case BUILT_IN_FPRINTF_CHK:
10535     case BUILT_IN_VFPRINTF_CHK:
10536       if (!validate_arg (arg1, INTEGER_TYPE)
10537           || TREE_SIDE_EFFECTS (arg1))
10538         return NULL_TREE;
10539       else
10540         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10541                                      ignore, fcode);
10542
10543     default:
10544       break;
10545     }
10546   return NULL_TREE;
10547 }
10548
10549 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10550    ARG2, and ARG3.  IGNORE is true if the result of the function call is
10551    ignored.  This function returns NULL_TREE if no simplification was
10552    possible.  */
10553
10554 static tree
10555 fold_builtin_4 (location_t loc, tree fndecl,
10556                 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10557 {
10558   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10559
10560   switch (fcode)
10561     {
10562     case BUILT_IN_MEMCPY_CHK:
10563     case BUILT_IN_MEMPCPY_CHK:
10564     case BUILT_IN_MEMMOVE_CHK:
10565     case BUILT_IN_MEMSET_CHK:
10566       return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10567                                       NULL_TREE, ignore,
10568                                       DECL_FUNCTION_CODE (fndecl));
10569
10570     case BUILT_IN_STRNCPY_CHK:
10571       return fold_builtin_strncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE);
10572
10573     case BUILT_IN_STRNCAT_CHK:
10574       return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
10575
10576     case BUILT_IN_FPRINTF_CHK:
10577     case BUILT_IN_VFPRINTF_CHK:
10578       if (!validate_arg (arg1, INTEGER_TYPE)
10579           || TREE_SIDE_EFFECTS (arg1))
10580         return NULL_TREE;
10581       else
10582         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
10583                                      ignore, fcode);
10584     break;
10585
10586     default:
10587       break;
10588     }
10589   return NULL_TREE;
10590 }
10591
10592 /* Fold a call to built-in function FNDECL.  ARGS is an array of NARGS
10593     arguments, where NARGS <= 4.  IGNORE is true if the result of the
10594     function call is ignored.  This function returns NULL_TREE if no
10595     simplification was possible.  Note that this only folds builtins with
10596     fixed argument patterns.  Foldings that do varargs-to-varargs
10597     transformations, or that match calls with more than 4 arguments,
10598     need to be handled with fold_builtin_varargs instead.  */
10599
10600 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10601
10602 static tree
10603 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
10604 {
10605   tree ret = NULL_TREE;
10606
10607   switch (nargs)
10608     {
10609     case 0:
10610       ret = fold_builtin_0 (loc, fndecl, ignore);
10611       break;
10612     case 1:
10613       ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
10614       break;
10615     case 2:
10616       ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
10617       break;
10618     case 3:
10619       ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
10620       break;
10621     case 4:
10622       ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
10623                             ignore);
10624       break;
10625     default:
10626       break;
10627     }
10628   if (ret)
10629     {
10630       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10631       SET_EXPR_LOCATION (ret, loc);
10632       TREE_NO_WARNING (ret) = 1;
10633       return ret;
10634     }
10635   return NULL_TREE;
10636 }
10637
10638 /* Builtins with folding operations that operate on "..." arguments
10639    need special handling; we need to store the arguments in a convenient
10640    data structure before attempting any folding.  Fortunately there are
10641    only a few builtins that fall into this category.  FNDECL is the
10642    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10643    result of the function call is ignored.  */
10644
10645 static tree
10646 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
10647                       bool ignore ATTRIBUTE_UNUSED)
10648 {
10649   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10650   tree ret = NULL_TREE;
10651
10652   switch (fcode)
10653     {
10654     case BUILT_IN_SPRINTF_CHK:
10655     case BUILT_IN_VSPRINTF_CHK:
10656       ret = fold_builtin_sprintf_chk (loc, exp, fcode);
10657       break;
10658
10659     case BUILT_IN_SNPRINTF_CHK:
10660     case BUILT_IN_VSNPRINTF_CHK:
10661       ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
10662       break;
10663
10664     case BUILT_IN_FPCLASSIFY:
10665       ret = fold_builtin_fpclassify (loc, exp);
10666       break;
10667
10668     default:
10669       break;
10670     }
10671   if (ret)
10672     {
10673       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10674       SET_EXPR_LOCATION (ret, loc);
10675       TREE_NO_WARNING (ret) = 1;
10676       return ret;
10677     }
10678   return NULL_TREE;
10679 }
10680
10681 /* Return true if FNDECL shouldn't be folded right now.
10682    If a built-in function has an inline attribute always_inline
10683    wrapper, defer folding it after always_inline functions have
10684    been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10685    might not be performed.  */
10686
10687 static bool
10688 avoid_folding_inline_builtin (tree fndecl)
10689 {
10690   return (DECL_DECLARED_INLINE_P (fndecl)
10691           && DECL_DISREGARD_INLINE_LIMITS (fndecl)
10692           && cfun
10693           && !cfun->always_inline_functions_inlined
10694           && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
10695 }
10696
10697 /* A wrapper function for builtin folding that prevents warnings for
10698    "statement without effect" and the like, caused by removing the
10699    call node earlier than the warning is generated.  */
10700
10701 tree
10702 fold_call_expr (location_t loc, tree exp, bool ignore)
10703 {
10704   tree ret = NULL_TREE;
10705   tree fndecl = get_callee_fndecl (exp);
10706   if (fndecl
10707       && TREE_CODE (fndecl) == FUNCTION_DECL
10708       && DECL_BUILT_IN (fndecl)
10709       /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10710          yet.  Defer folding until we see all the arguments
10711          (after inlining).  */
10712       && !CALL_EXPR_VA_ARG_PACK (exp))
10713     {
10714       int nargs = call_expr_nargs (exp);
10715
10716       /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10717          instead last argument is __builtin_va_arg_pack ().  Defer folding
10718          even in that case, until arguments are finalized.  */
10719       if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
10720         {
10721           tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
10722           if (fndecl2
10723               && TREE_CODE (fndecl2) == FUNCTION_DECL
10724               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10725               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10726             return NULL_TREE;
10727         }
10728
10729       if (avoid_folding_inline_builtin (fndecl))
10730         return NULL_TREE;
10731
10732       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10733         return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
10734                                      CALL_EXPR_ARGP (exp), ignore);
10735       else
10736         {
10737           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
10738             {
10739               tree *args = CALL_EXPR_ARGP (exp);
10740               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
10741             }
10742           if (!ret)
10743             ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
10744           if (ret)
10745             return ret;
10746         }
10747     }
10748   return NULL_TREE;
10749 }
10750
10751 /* Conveniently construct a function call expression.  FNDECL names the
10752    function to be called and N arguments are passed in the array
10753    ARGARRAY.  */
10754
10755 tree
10756 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
10757 {
10758   tree fntype = TREE_TYPE (fndecl);
10759   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10760
10761   return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10762 }
10763
10764 /* Conveniently construct a function call expression.  FNDECL names the
10765    function to be called and the arguments are passed in the vector
10766    VEC.  */
10767
10768 tree
10769 build_call_expr_loc_vec (location_t loc, tree fndecl, VEC(tree,gc) *vec)
10770 {
10771   return build_call_expr_loc_array (loc, fndecl, VEC_length (tree, vec),
10772                                     VEC_address (tree, vec));
10773 }
10774
10775
10776 /* Conveniently construct a function call expression.  FNDECL names the
10777    function to be called, N is the number of arguments, and the "..."
10778    parameters are the argument expressions.  */
10779
10780 tree
10781 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10782 {
10783   va_list ap;
10784   tree *argarray = XALLOCAVEC (tree, n);
10785   int i;
10786
10787   va_start (ap, n);
10788   for (i = 0; i < n; i++)
10789     argarray[i] = va_arg (ap, tree);
10790   va_end (ap);
10791   return build_call_expr_loc_array (loc, fndecl, n, argarray);
10792 }
10793
10794 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...).  Duplicated because
10795    varargs macros aren't supported by all bootstrap compilers.  */
10796
10797 tree
10798 build_call_expr (tree fndecl, int n, ...)
10799 {
10800   va_list ap;
10801   tree *argarray = XALLOCAVEC (tree, n);
10802   int i;
10803
10804   va_start (ap, n);
10805   for (i = 0; i < n; i++)
10806     argarray[i] = va_arg (ap, tree);
10807   va_end (ap);
10808   return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
10809 }
10810
10811 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10812    N arguments are passed in the array ARGARRAY.  */
10813
10814 tree
10815 fold_builtin_call_array (location_t loc, tree type,
10816                          tree fn,
10817                          int n,
10818                          tree *argarray)
10819 {
10820   tree ret = NULL_TREE;
10821    tree exp;
10822
10823   if (TREE_CODE (fn) == ADDR_EXPR)
10824   {
10825     tree fndecl = TREE_OPERAND (fn, 0);
10826     if (TREE_CODE (fndecl) == FUNCTION_DECL
10827         && DECL_BUILT_IN (fndecl))
10828       {
10829         /* If last argument is __builtin_va_arg_pack (), arguments to this
10830            function are not finalized yet.  Defer folding until they are.  */
10831         if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
10832           {
10833             tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
10834             if (fndecl2
10835                 && TREE_CODE (fndecl2) == FUNCTION_DECL
10836                 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10837                 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10838               return build_call_array_loc (loc, type, fn, n, argarray);
10839           }
10840         if (avoid_folding_inline_builtin (fndecl))
10841           return build_call_array_loc (loc, type, fn, n, argarray);
10842         if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10843           {
10844             ret = targetm.fold_builtin (fndecl, n, argarray, false);
10845             if (ret)
10846               return ret;
10847
10848             return build_call_array_loc (loc, type, fn, n, argarray);
10849           }
10850         else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
10851           {
10852             /* First try the transformations that don't require consing up
10853                an exp.  */
10854             ret = fold_builtin_n (loc, fndecl, argarray, n, false);
10855             if (ret)
10856               return ret;
10857           }
10858
10859         /* If we got this far, we need to build an exp.  */
10860         exp = build_call_array_loc (loc, type, fn, n, argarray);
10861         ret = fold_builtin_varargs (loc, fndecl, exp, false);
10862         return ret ? ret : exp;
10863       }
10864   }
10865
10866   return build_call_array_loc (loc, type, fn, n, argarray);
10867 }
10868
10869 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10870    along with N new arguments specified as the "..." parameters.  SKIP
10871    is the number of arguments in EXP to be omitted.  This function is used
10872    to do varargs-to-varargs transformations.  */
10873
10874 static tree
10875 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
10876 {
10877   int oldnargs = call_expr_nargs (exp);
10878   int nargs = oldnargs - skip + n;
10879   tree fntype = TREE_TYPE (fndecl);
10880   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10881   tree *buffer;
10882
10883   if (n > 0)
10884     {
10885       int i, j;
10886       va_list ap;
10887
10888       buffer = XALLOCAVEC (tree, nargs);
10889       va_start (ap, n);
10890       for (i = 0; i < n; i++)
10891         buffer[i] = va_arg (ap, tree);
10892       va_end (ap);
10893       for (j = skip; j < oldnargs; j++, i++)
10894         buffer[i] = CALL_EXPR_ARG (exp, j);
10895     }
10896   else
10897     buffer = CALL_EXPR_ARGP (exp) + skip;
10898
10899   return fold (build_call_array_loc (loc, TREE_TYPE (exp), fn, nargs, buffer));
10900 }
10901
10902 /* Validate a single argument ARG against a tree code CODE representing
10903    a type.  */
10904
10905 static bool
10906 validate_arg (const_tree arg, enum tree_code code)
10907 {
10908   if (!arg)
10909     return false;
10910   else if (code == POINTER_TYPE)
10911     return POINTER_TYPE_P (TREE_TYPE (arg));
10912   else if (code == INTEGER_TYPE)
10913     return INTEGRAL_TYPE_P (TREE_TYPE (arg));
10914   return code == TREE_CODE (TREE_TYPE (arg));
10915 }
10916
10917 /* This function validates the types of a function call argument list
10918    against a specified list of tree_codes.  If the last specifier is a 0,
10919    that represents an ellipses, otherwise the last specifier must be a
10920    VOID_TYPE.
10921
10922    This is the GIMPLE version of validate_arglist.  Eventually we want to
10923    completely convert builtins.c to work from GIMPLEs and the tree based
10924    validate_arglist will then be removed.  */
10925
10926 bool
10927 validate_gimple_arglist (const_gimple call, ...)
10928 {
10929   enum tree_code code;
10930   bool res = 0;
10931   va_list ap;
10932   const_tree arg;
10933   size_t i;
10934
10935   va_start (ap, call);
10936   i = 0;
10937
10938   do
10939     {
10940       code = (enum tree_code) va_arg (ap, int);
10941       switch (code)
10942         {
10943         case 0:
10944           /* This signifies an ellipses, any further arguments are all ok.  */
10945           res = true;
10946           goto end;
10947         case VOID_TYPE:
10948           /* This signifies an endlink, if no arguments remain, return
10949              true, otherwise return false.  */
10950           res = (i == gimple_call_num_args (call));
10951           goto end;
10952         default:
10953           /* If no parameters remain or the parameter's code does not
10954              match the specified code, return false.  Otherwise continue
10955              checking any remaining arguments.  */
10956           arg = gimple_call_arg (call, i++);
10957           if (!validate_arg (arg, code))
10958             goto end;
10959           break;
10960         }
10961     }
10962   while (1);
10963
10964   /* We need gotos here since we can only have one VA_CLOSE in a
10965      function.  */
10966  end: ;
10967   va_end (ap);
10968
10969   return res;
10970 }
10971
10972 /* This function validates the types of a function call argument list
10973    against a specified list of tree_codes.  If the last specifier is a 0,
10974    that represents an ellipses, otherwise the last specifier must be a
10975    VOID_TYPE.  */
10976
10977 bool
10978 validate_arglist (const_tree callexpr, ...)
10979 {
10980   enum tree_code code;
10981   bool res = 0;
10982   va_list ap;
10983   const_call_expr_arg_iterator iter;
10984   const_tree arg;
10985
10986   va_start (ap, callexpr);
10987   init_const_call_expr_arg_iterator (callexpr, &iter);
10988
10989   do
10990     {
10991       code = (enum tree_code) va_arg (ap, int);
10992       switch (code)
10993         {
10994         case 0:
10995           /* This signifies an ellipses, any further arguments are all ok.  */
10996           res = true;
10997           goto end;
10998         case VOID_TYPE:
10999           /* This signifies an endlink, if no arguments remain, return
11000              true, otherwise return false.  */
11001           res = !more_const_call_expr_args_p (&iter);
11002           goto end;
11003         default:
11004           /* If no parameters remain or the parameter's code does not
11005              match the specified code, return false.  Otherwise continue
11006              checking any remaining arguments.  */
11007           arg = next_const_call_expr_arg (&iter);
11008           if (!validate_arg (arg, code))
11009             goto end;
11010           break;
11011         }
11012     }
11013   while (1);
11014
11015   /* We need gotos here since we can only have one VA_CLOSE in a
11016      function.  */
11017  end: ;
11018   va_end (ap);
11019
11020   return res;
11021 }
11022
11023 /* Default target-specific builtin expander that does nothing.  */
11024
11025 rtx
11026 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11027                         rtx target ATTRIBUTE_UNUSED,
11028                         rtx subtarget ATTRIBUTE_UNUSED,
11029                         enum machine_mode mode ATTRIBUTE_UNUSED,
11030                         int ignore ATTRIBUTE_UNUSED)
11031 {
11032   return NULL_RTX;
11033 }
11034
11035 /* Returns true is EXP represents data that would potentially reside
11036    in a readonly section.  */
11037
11038 static bool
11039 readonly_data_expr (tree exp)
11040 {
11041   STRIP_NOPS (exp);
11042
11043   if (TREE_CODE (exp) != ADDR_EXPR)
11044     return false;
11045
11046   exp = get_base_address (TREE_OPERAND (exp, 0));
11047   if (!exp)
11048     return false;
11049
11050   /* Make sure we call decl_readonly_section only for trees it
11051      can handle (since it returns true for everything it doesn't
11052      understand).  */
11053   if (TREE_CODE (exp) == STRING_CST
11054       || TREE_CODE (exp) == CONSTRUCTOR
11055       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11056     return decl_readonly_section (exp, 0);
11057   else
11058     return false;
11059 }
11060
11061 /* Simplify a call to the strstr builtin.  S1 and S2 are the arguments
11062    to the call, and TYPE is its return type.
11063
11064    Return NULL_TREE if no simplification was possible, otherwise return the
11065    simplified form of the call as a tree.
11066
11067    The simplified form may be a constant or other expression which
11068    computes the same value, but in a more efficient manner (including
11069    calls to other builtin functions).
11070
11071    The call may contain arguments which need to be evaluated, but
11072    which are not useful to determine the result of the call.  In
11073    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11074    COMPOUND_EXPR will be an argument which must be evaluated.
11075    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11076    COMPOUND_EXPR in the chain will contain the tree for the simplified
11077    form of the builtin function call.  */
11078
11079 static tree
11080 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11081 {
11082   if (!validate_arg (s1, POINTER_TYPE)
11083       || !validate_arg (s2, POINTER_TYPE))
11084     return NULL_TREE;
11085   else
11086     {
11087       tree fn;
11088       const char *p1, *p2;
11089
11090       p2 = c_getstr (s2);
11091       if (p2 == NULL)
11092         return NULL_TREE;
11093
11094       p1 = c_getstr (s1);
11095       if (p1 != NULL)
11096         {
11097           const char *r = strstr (p1, p2);
11098           tree tem;
11099
11100           if (r == NULL)
11101             return build_int_cst (TREE_TYPE (s1), 0);
11102
11103           /* Return an offset into the constant string argument.  */
11104           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11105                              s1, size_int (r - p1));
11106           return fold_convert_loc (loc, type, tem);
11107         }
11108
11109       /* The argument is const char *, and the result is char *, so we need
11110          a type conversion here to avoid a warning.  */
11111       if (p2[0] == '\0')
11112         return fold_convert_loc (loc, type, s1);
11113
11114       if (p2[1] != '\0')
11115         return NULL_TREE;
11116
11117       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11118       if (!fn)
11119         return NULL_TREE;
11120
11121       /* New argument list transforming strstr(s1, s2) to
11122          strchr(s1, s2[0]).  */
11123       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11124     }
11125 }
11126
11127 /* Simplify a call to the strchr builtin.  S1 and S2 are the arguments to
11128    the call, and TYPE is its return type.
11129
11130    Return NULL_TREE if no simplification was possible, otherwise return the
11131    simplified form of the call as a tree.
11132
11133    The simplified form may be a constant or other expression which
11134    computes the same value, but in a more efficient manner (including
11135    calls to other builtin functions).
11136
11137    The call may contain arguments which need to be evaluated, but
11138    which are not useful to determine the result of the call.  In
11139    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11140    COMPOUND_EXPR will be an argument which must be evaluated.
11141    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11142    COMPOUND_EXPR in the chain will contain the tree for the simplified
11143    form of the builtin function call.  */
11144
11145 static tree
11146 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11147 {
11148   if (!validate_arg (s1, POINTER_TYPE)
11149       || !validate_arg (s2, INTEGER_TYPE))
11150     return NULL_TREE;
11151   else
11152     {
11153       const char *p1;
11154
11155       if (TREE_CODE (s2) != INTEGER_CST)
11156         return NULL_TREE;
11157
11158       p1 = c_getstr (s1);
11159       if (p1 != NULL)
11160         {
11161           char c;
11162           const char *r;
11163           tree tem;
11164
11165           if (target_char_cast (s2, &c))
11166             return NULL_TREE;
11167
11168           r = strchr (p1, c);
11169
11170           if (r == NULL)
11171             return build_int_cst (TREE_TYPE (s1), 0);
11172
11173           /* Return an offset into the constant string argument.  */
11174           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11175                              s1, size_int (r - p1));
11176           return fold_convert_loc (loc, type, tem);
11177         }
11178       return NULL_TREE;
11179     }
11180 }
11181
11182 /* Simplify a call to the strrchr builtin.  S1 and S2 are the arguments to
11183    the call, and TYPE is its return type.
11184
11185    Return NULL_TREE if no simplification was possible, otherwise return the
11186    simplified form of the call as a tree.
11187
11188    The simplified form may be a constant or other expression which
11189    computes the same value, but in a more efficient manner (including
11190    calls to other builtin functions).
11191
11192    The call may contain arguments which need to be evaluated, but
11193    which are not useful to determine the result of the call.  In
11194    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11195    COMPOUND_EXPR will be an argument which must be evaluated.
11196    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11197    COMPOUND_EXPR in the chain will contain the tree for the simplified
11198    form of the builtin function call.  */
11199
11200 static tree
11201 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11202 {
11203   if (!validate_arg (s1, POINTER_TYPE)
11204       || !validate_arg (s2, INTEGER_TYPE))
11205     return NULL_TREE;
11206   else
11207     {
11208       tree fn;
11209       const char *p1;
11210
11211       if (TREE_CODE (s2) != INTEGER_CST)
11212         return NULL_TREE;
11213
11214       p1 = c_getstr (s1);
11215       if (p1 != NULL)
11216         {
11217           char c;
11218           const char *r;
11219           tree tem;
11220
11221           if (target_char_cast (s2, &c))
11222             return NULL_TREE;
11223
11224           r = strrchr (p1, c);
11225
11226           if (r == NULL)
11227             return build_int_cst (TREE_TYPE (s1), 0);
11228
11229           /* Return an offset into the constant string argument.  */
11230           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11231                              s1, size_int (r - p1));
11232           return fold_convert_loc (loc, type, tem);
11233         }
11234
11235       if (! integer_zerop (s2))
11236         return NULL_TREE;
11237
11238       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11239       if (!fn)
11240         return NULL_TREE;
11241
11242       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
11243       return build_call_expr_loc (loc, fn, 2, s1, s2);
11244     }
11245 }
11246
11247 /* Simplify a call to the strpbrk builtin.  S1 and S2 are the arguments
11248    to the call, and TYPE is its return type.
11249
11250    Return NULL_TREE if no simplification was possible, otherwise return the
11251    simplified form of the call as a tree.
11252
11253    The simplified form may be a constant or other expression which
11254    computes the same value, but in a more efficient manner (including
11255    calls to other builtin functions).
11256
11257    The call may contain arguments which need to be evaluated, but
11258    which are not useful to determine the result of the call.  In
11259    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11260    COMPOUND_EXPR will be an argument which must be evaluated.
11261    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11262    COMPOUND_EXPR in the chain will contain the tree for the simplified
11263    form of the builtin function call.  */
11264
11265 static tree
11266 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11267 {
11268   if (!validate_arg (s1, POINTER_TYPE)
11269       || !validate_arg (s2, POINTER_TYPE))
11270     return NULL_TREE;
11271   else
11272     {
11273       tree fn;
11274       const char *p1, *p2;
11275
11276       p2 = c_getstr (s2);
11277       if (p2 == NULL)
11278         return NULL_TREE;
11279
11280       p1 = c_getstr (s1);
11281       if (p1 != NULL)
11282         {
11283           const char *r = strpbrk (p1, p2);
11284           tree tem;
11285
11286           if (r == NULL)
11287             return build_int_cst (TREE_TYPE (s1), 0);
11288
11289           /* Return an offset into the constant string argument.  */
11290           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11291                              s1, size_int (r - p1));
11292           return fold_convert_loc (loc, type, tem);
11293         }
11294
11295       if (p2[0] == '\0')
11296         /* strpbrk(x, "") == NULL.
11297            Evaluate and ignore s1 in case it had side-effects.  */
11298         return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11299
11300       if (p2[1] != '\0')
11301         return NULL_TREE;  /* Really call strpbrk.  */
11302
11303       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11304       if (!fn)
11305         return NULL_TREE;
11306
11307       /* New argument list transforming strpbrk(s1, s2) to
11308          strchr(s1, s2[0]).  */
11309       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11310     }
11311 }
11312
11313 /* Simplify a call to the strcat builtin.  DST and SRC are the arguments
11314    to the call.
11315
11316    Return NULL_TREE if no simplification was possible, otherwise return the
11317    simplified form of the call as a tree.
11318
11319    The simplified form may be a constant or other expression which
11320    computes the same value, but in a more efficient manner (including
11321    calls to other builtin functions).
11322
11323    The call may contain arguments which need to be evaluated, but
11324    which are not useful to determine the result of the call.  In
11325    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11326    COMPOUND_EXPR will be an argument which must be evaluated.
11327    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11328    COMPOUND_EXPR in the chain will contain the tree for the simplified
11329    form of the builtin function call.  */
11330
11331 static tree
11332 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11333 {
11334   if (!validate_arg (dst, POINTER_TYPE)
11335       || !validate_arg (src, POINTER_TYPE))
11336     return NULL_TREE;
11337   else
11338     {
11339       const char *p = c_getstr (src);
11340
11341       /* If the string length is zero, return the dst parameter.  */
11342       if (p && *p == '\0')
11343         return dst;
11344
11345       if (optimize_insn_for_speed_p ())
11346         {
11347           /* See if we can store by pieces into (dst + strlen(dst)).  */
11348           tree newdst, call;
11349           tree strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11350           tree strcpy_fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11351
11352           if (!strlen_fn || !strcpy_fn)
11353             return NULL_TREE;
11354
11355           /* If we don't have a movstr we don't want to emit an strcpy
11356              call.  We have to do that if the length of the source string
11357              isn't computable (in that case we can use memcpy probably
11358              later expanding to a sequence of mov instructions).  If we
11359              have movstr instructions we can emit strcpy calls.  */
11360           if (!HAVE_movstr)
11361             {
11362               tree len = c_strlen (src, 1);
11363               if (! len || TREE_SIDE_EFFECTS (len))
11364                 return NULL_TREE;
11365             }
11366
11367           /* Stabilize the argument list.  */
11368           dst = builtin_save_expr (dst);
11369
11370           /* Create strlen (dst).  */
11371           newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11372           /* Create (dst p+ strlen (dst)).  */
11373
11374           newdst = fold_build2_loc (loc, POINTER_PLUS_EXPR,
11375                                 TREE_TYPE (dst), dst, newdst);
11376           newdst = builtin_save_expr (newdst);
11377
11378           call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11379           return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11380         }
11381       return NULL_TREE;
11382     }
11383 }
11384
11385 /* Simplify a call to the strncat builtin.  DST, SRC, and LEN are the
11386    arguments to the call.
11387
11388    Return NULL_TREE if no simplification was possible, otherwise return the
11389    simplified form of the call as a tree.
11390
11391    The simplified form may be a constant or other expression which
11392    computes the same value, but in a more efficient manner (including
11393    calls to other builtin functions).
11394
11395    The call may contain arguments which need to be evaluated, but
11396    which are not useful to determine the result of the call.  In
11397    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11398    COMPOUND_EXPR will be an argument which must be evaluated.
11399    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11400    COMPOUND_EXPR in the chain will contain the tree for the simplified
11401    form of the builtin function call.  */
11402
11403 static tree
11404 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11405 {
11406   if (!validate_arg (dst, POINTER_TYPE)
11407       || !validate_arg (src, POINTER_TYPE)
11408       || !validate_arg (len, INTEGER_TYPE))
11409     return NULL_TREE;
11410   else
11411     {
11412       const char *p = c_getstr (src);
11413
11414       /* If the requested length is zero, or the src parameter string
11415          length is zero, return the dst parameter.  */
11416       if (integer_zerop (len) || (p && *p == '\0'))
11417         return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11418
11419       /* If the requested len is greater than or equal to the string
11420          length, call strcat.  */
11421       if (TREE_CODE (len) == INTEGER_CST && p
11422           && compare_tree_int (len, strlen (p)) >= 0)
11423         {
11424           tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
11425
11426           /* If the replacement _DECL isn't initialized, don't do the
11427              transformation.  */
11428           if (!fn)
11429             return NULL_TREE;
11430
11431           return build_call_expr_loc (loc, fn, 2, dst, src);
11432         }
11433       return NULL_TREE;
11434     }
11435 }
11436
11437 /* Simplify a call to the strspn builtin.  S1 and S2 are the arguments
11438    to the call.
11439
11440    Return NULL_TREE if no simplification was possible, otherwise return the
11441    simplified form of the call as a tree.
11442
11443    The simplified form may be a constant or other expression which
11444    computes the same value, but in a more efficient manner (including
11445    calls to other builtin functions).
11446
11447    The call may contain arguments which need to be evaluated, but
11448    which are not useful to determine the result of the call.  In
11449    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11450    COMPOUND_EXPR will be an argument which must be evaluated.
11451    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11452    COMPOUND_EXPR in the chain will contain the tree for the simplified
11453    form of the builtin function call.  */
11454
11455 static tree
11456 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11457 {
11458   if (!validate_arg (s1, POINTER_TYPE)
11459       || !validate_arg (s2, POINTER_TYPE))
11460     return NULL_TREE;
11461   else
11462     {
11463       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11464
11465       /* If both arguments are constants, evaluate at compile-time.  */
11466       if (p1 && p2)
11467         {
11468           const size_t r = strspn (p1, p2);
11469           return size_int (r);
11470         }
11471
11472       /* If either argument is "", return NULL_TREE.  */
11473       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11474         /* Evaluate and ignore both arguments in case either one has
11475            side-effects.  */
11476         return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11477                                   s1, s2);
11478       return NULL_TREE;
11479     }
11480 }
11481
11482 /* Simplify a call to the strcspn builtin.  S1 and S2 are the arguments
11483    to the call.
11484
11485    Return NULL_TREE if no simplification was possible, otherwise return the
11486    simplified form of the call as a tree.
11487
11488    The simplified form may be a constant or other expression which
11489    computes the same value, but in a more efficient manner (including
11490    calls to other builtin functions).
11491
11492    The call may contain arguments which need to be evaluated, but
11493    which are not useful to determine the result of the call.  In
11494    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11495    COMPOUND_EXPR will be an argument which must be evaluated.
11496    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11497    COMPOUND_EXPR in the chain will contain the tree for the simplified
11498    form of the builtin function call.  */
11499
11500 static tree
11501 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11502 {
11503   if (!validate_arg (s1, POINTER_TYPE)
11504       || !validate_arg (s2, POINTER_TYPE))
11505     return NULL_TREE;
11506   else
11507     {
11508       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11509
11510       /* If both arguments are constants, evaluate at compile-time.  */
11511       if (p1 && p2)
11512         {
11513           const size_t r = strcspn (p1, p2);
11514           return size_int (r);
11515         }
11516
11517       /* If the first argument is "", return NULL_TREE.  */
11518       if (p1 && *p1 == '\0')
11519         {
11520           /* Evaluate and ignore argument s2 in case it has
11521              side-effects.  */
11522           return omit_one_operand_loc (loc, size_type_node,
11523                                    size_zero_node, s2);
11524         }
11525
11526       /* If the second argument is "", return __builtin_strlen(s1).  */
11527       if (p2 && *p2 == '\0')
11528         {
11529           tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11530
11531           /* If the replacement _DECL isn't initialized, don't do the
11532              transformation.  */
11533           if (!fn)
11534             return NULL_TREE;
11535
11536           return build_call_expr_loc (loc, fn, 1, s1);
11537         }
11538       return NULL_TREE;
11539     }
11540 }
11541
11542 /* Fold a call to the fputs builtin.  ARG0 and ARG1 are the arguments
11543    to the call.  IGNORE is true if the value returned
11544    by the builtin will be ignored.  UNLOCKED is true is true if this
11545    actually a call to fputs_unlocked.  If LEN in non-NULL, it represents
11546    the known length of the string.  Return NULL_TREE if no simplification
11547    was possible.  */
11548
11549 tree
11550 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
11551                     bool ignore, bool unlocked, tree len)
11552 {
11553   /* If we're using an unlocked function, assume the other unlocked
11554      functions exist explicitly.  */
11555   tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
11556     : implicit_built_in_decls[BUILT_IN_FPUTC];
11557   tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
11558     : implicit_built_in_decls[BUILT_IN_FWRITE];
11559
11560   /* If the return value is used, don't do the transformation.  */
11561   if (!ignore)
11562     return NULL_TREE;
11563
11564   /* Verify the arguments in the original call.  */
11565   if (!validate_arg (arg0, POINTER_TYPE)
11566       || !validate_arg (arg1, POINTER_TYPE))
11567     return NULL_TREE;
11568
11569   if (! len)
11570     len = c_strlen (arg0, 0);
11571
11572   /* Get the length of the string passed to fputs.  If the length
11573      can't be determined, punt.  */
11574   if (!len
11575       || TREE_CODE (len) != INTEGER_CST)
11576     return NULL_TREE;
11577
11578   switch (compare_tree_int (len, 1))
11579     {
11580     case -1: /* length is 0, delete the call entirely .  */
11581       return omit_one_operand_loc (loc, integer_type_node,
11582                                integer_zero_node, arg1);;
11583
11584     case 0: /* length is 1, call fputc.  */
11585       {
11586         const char *p = c_getstr (arg0);
11587
11588         if (p != NULL)
11589           {
11590             if (fn_fputc)
11591               return build_call_expr_loc (loc, fn_fputc, 2,
11592                                       build_int_cst (NULL_TREE, p[0]), arg1);
11593             else
11594               return NULL_TREE;
11595           }
11596       }
11597       /* FALLTHROUGH */
11598     case 1: /* length is greater than 1, call fwrite.  */
11599       {
11600         /* If optimizing for size keep fputs.  */
11601         if (optimize_function_for_size_p (cfun))
11602           return NULL_TREE;
11603         /* New argument list transforming fputs(string, stream) to
11604            fwrite(string, 1, len, stream).  */
11605         if (fn_fwrite)
11606           return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
11607                                   size_one_node, len, arg1);
11608         else
11609           return NULL_TREE;
11610       }
11611     default:
11612       gcc_unreachable ();
11613     }
11614   return NULL_TREE;
11615 }
11616
11617 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11618    produced.  False otherwise.  This is done so that we don't output the error
11619    or warning twice or three times.  */
11620
11621 bool
11622 fold_builtin_next_arg (tree exp, bool va_start_p)
11623 {
11624   tree fntype = TREE_TYPE (current_function_decl);
11625   int nargs = call_expr_nargs (exp);
11626   tree arg;
11627
11628   if (!stdarg_p (fntype))
11629     {
11630       error ("%<va_start%> used in function with fixed args");
11631       return true;
11632     }
11633
11634   if (va_start_p)
11635     {
11636       if (va_start_p && (nargs != 2))
11637         {
11638           error ("wrong number of arguments to function %<va_start%>");
11639           return true;
11640         }
11641       arg = CALL_EXPR_ARG (exp, 1);
11642     }
11643   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11644      when we checked the arguments and if needed issued a warning.  */
11645   else
11646     {
11647       if (nargs == 0)
11648         {
11649           /* Evidently an out of date version of <stdarg.h>; can't validate
11650              va_start's second argument, but can still work as intended.  */
11651           warning (0, "%<__builtin_next_arg%> called without an argument");
11652           return true;
11653         }
11654       else if (nargs > 1)
11655         {
11656           error ("wrong number of arguments to function %<__builtin_next_arg%>");
11657           return true;
11658         }
11659       arg = CALL_EXPR_ARG (exp, 0);
11660     }
11661
11662   if (TREE_CODE (arg) == SSA_NAME)
11663     arg = SSA_NAME_VAR (arg);
11664
11665   /* We destructively modify the call to be __builtin_va_start (ap, 0)
11666      or __builtin_next_arg (0) the first time we see it, after checking
11667      the arguments and if needed issuing a warning.  */
11668   if (!integer_zerop (arg))
11669     {
11670       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
11671
11672       /* Strip off all nops for the sake of the comparison.  This
11673          is not quite the same as STRIP_NOPS.  It does more.
11674          We must also strip off INDIRECT_EXPR for C++ reference
11675          parameters.  */
11676       while (CONVERT_EXPR_P (arg)
11677              || TREE_CODE (arg) == INDIRECT_REF)
11678         arg = TREE_OPERAND (arg, 0);
11679       if (arg != last_parm)
11680         {
11681           /* FIXME: Sometimes with the tree optimizers we can get the
11682              not the last argument even though the user used the last
11683              argument.  We just warn and set the arg to be the last
11684              argument so that we will get wrong-code because of
11685              it.  */
11686           warning (0, "second parameter of %<va_start%> not last named argument");
11687         }
11688
11689       /* Undefined by C99 7.15.1.4p4 (va_start):
11690          "If the parameter parmN is declared with the register storage
11691          class, with a function or array type, or with a type that is
11692          not compatible with the type that results after application of
11693          the default argument promotions, the behavior is undefined."
11694       */
11695       else if (DECL_REGISTER (arg))
11696         warning (0, "undefined behaviour when second parameter of "
11697                  "%<va_start%> is declared with %<register%> storage");
11698
11699       /* We want to verify the second parameter just once before the tree
11700          optimizers are run and then avoid keeping it in the tree,
11701          as otherwise we could warn even for correct code like:
11702          void foo (int i, ...)
11703          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
11704       if (va_start_p)
11705         CALL_EXPR_ARG (exp, 1) = integer_zero_node;
11706       else
11707         CALL_EXPR_ARG (exp, 0) = integer_zero_node;
11708     }
11709   return false;
11710 }
11711
11712
11713 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11714    ORIG may be null if this is a 2-argument call.  We don't attempt to
11715    simplify calls with more than 3 arguments.
11716
11717    Return NULL_TREE if no simplification was possible, otherwise return the
11718    simplified form of the call as a tree.  If IGNORED is true, it means that
11719    the caller does not use the returned value of the function.  */
11720
11721 static tree
11722 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
11723                       tree orig, int ignored)
11724 {
11725   tree call, retval;
11726   const char *fmt_str = NULL;
11727
11728   /* Verify the required arguments in the original call.  We deal with two
11729      types of sprintf() calls: 'sprintf (str, fmt)' and
11730      'sprintf (dest, "%s", orig)'.  */
11731   if (!validate_arg (dest, POINTER_TYPE)
11732       || !validate_arg (fmt, POINTER_TYPE))
11733     return NULL_TREE;
11734   if (orig && !validate_arg (orig, POINTER_TYPE))
11735     return NULL_TREE;
11736
11737   /* Check whether the format is a literal string constant.  */
11738   fmt_str = c_getstr (fmt);
11739   if (fmt_str == NULL)
11740     return NULL_TREE;
11741
11742   call = NULL_TREE;
11743   retval = NULL_TREE;
11744
11745   if (!init_target_chars ())
11746     return NULL_TREE;
11747
11748   /* If the format doesn't contain % args or %%, use strcpy.  */
11749   if (strchr (fmt_str, target_percent) == NULL)
11750     {
11751       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11752
11753       if (!fn)
11754         return NULL_TREE;
11755
11756       /* Don't optimize sprintf (buf, "abc", ptr++).  */
11757       if (orig)
11758         return NULL_TREE;
11759
11760       /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11761          'format' is known to contain no % formats.  */
11762       call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11763       if (!ignored)
11764         retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11765     }
11766
11767   /* If the format is "%s", use strcpy if the result isn't used.  */
11768   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11769     {
11770       tree fn;
11771       fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11772
11773       if (!fn)
11774         return NULL_TREE;
11775
11776       /* Don't crash on sprintf (str1, "%s").  */
11777       if (!orig)
11778         return NULL_TREE;
11779
11780       /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2).  */
11781       if (!ignored)
11782         {
11783           retval = c_strlen (orig, 1);
11784           if (!retval || TREE_CODE (retval) != INTEGER_CST)
11785             return NULL_TREE;
11786         }
11787       call = build_call_expr_loc (loc, fn, 2, dest, orig);
11788     }
11789
11790   if (call && retval)
11791     {
11792       retval = fold_convert_loc
11793         (loc, TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
11794          retval);
11795       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11796     }
11797   else
11798     return call;
11799 }
11800
11801 /* Expand a call EXP to __builtin_object_size.  */
11802
11803 rtx
11804 expand_builtin_object_size (tree exp)
11805 {
11806   tree ost;
11807   int object_size_type;
11808   tree fndecl = get_callee_fndecl (exp);
11809
11810   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
11811     {
11812       error ("%Kfirst argument of %D must be a pointer, second integer constant",
11813              exp, fndecl);
11814       expand_builtin_trap ();
11815       return const0_rtx;
11816     }
11817
11818   ost = CALL_EXPR_ARG (exp, 1);
11819   STRIP_NOPS (ost);
11820
11821   if (TREE_CODE (ost) != INTEGER_CST
11822       || tree_int_cst_sgn (ost) < 0
11823       || compare_tree_int (ost, 3) > 0)
11824     {
11825       error ("%Klast argument of %D is not integer constant between 0 and 3",
11826              exp, fndecl);
11827       expand_builtin_trap ();
11828       return const0_rtx;
11829     }
11830
11831   object_size_type = tree_low_cst (ost, 0);
11832
11833   return object_size_type < 2 ? constm1_rtx : const0_rtx;
11834 }
11835
11836 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11837    FCODE is the BUILT_IN_* to use.
11838    Return NULL_RTX if we failed; the caller should emit a normal call,
11839    otherwise try to get the result in TARGET, if convenient (and in
11840    mode MODE if that's convenient).  */
11841
11842 static rtx
11843 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
11844                            enum built_in_function fcode)
11845 {
11846   tree dest, src, len, size;
11847
11848   if (!validate_arglist (exp,
11849                          POINTER_TYPE,
11850                          fcode == BUILT_IN_MEMSET_CHK
11851                          ? INTEGER_TYPE : POINTER_TYPE,
11852                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
11853     return NULL_RTX;
11854
11855   dest = CALL_EXPR_ARG (exp, 0);
11856   src = CALL_EXPR_ARG (exp, 1);
11857   len = CALL_EXPR_ARG (exp, 2);
11858   size = CALL_EXPR_ARG (exp, 3);
11859
11860   if (! host_integerp (size, 1))
11861     return NULL_RTX;
11862
11863   if (host_integerp (len, 1) || integer_all_onesp (size))
11864     {
11865       tree fn;
11866
11867       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
11868         {
11869           warning_at (tree_nonartificial_location (exp),
11870                       0, "%Kcall to %D will always overflow destination buffer",
11871                       exp, get_callee_fndecl (exp));
11872           return NULL_RTX;
11873         }
11874
11875       fn = NULL_TREE;
11876       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11877          mem{cpy,pcpy,move,set} is available.  */
11878       switch (fcode)
11879         {
11880         case BUILT_IN_MEMCPY_CHK:
11881           fn = built_in_decls[BUILT_IN_MEMCPY];
11882           break;
11883         case BUILT_IN_MEMPCPY_CHK:
11884           fn = built_in_decls[BUILT_IN_MEMPCPY];
11885           break;
11886         case BUILT_IN_MEMMOVE_CHK:
11887           fn = built_in_decls[BUILT_IN_MEMMOVE];
11888           break;
11889         case BUILT_IN_MEMSET_CHK:
11890           fn = built_in_decls[BUILT_IN_MEMSET];
11891           break;
11892         default:
11893           break;
11894         }
11895
11896       if (! fn)
11897         return NULL_RTX;
11898
11899       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
11900       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
11901       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11902       return expand_expr (fn, target, mode, EXPAND_NORMAL);
11903     }
11904   else if (fcode == BUILT_IN_MEMSET_CHK)
11905     return NULL_RTX;
11906   else
11907     {
11908       unsigned int dest_align
11909         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
11910
11911       /* If DEST is not a pointer type, call the normal function.  */
11912       if (dest_align == 0)
11913         return NULL_RTX;
11914
11915       /* If SRC and DEST are the same (and not volatile), do nothing.  */
11916       if (operand_equal_p (src, dest, 0))
11917         {
11918           tree expr;
11919
11920           if (fcode != BUILT_IN_MEMPCPY_CHK)
11921             {
11922               /* Evaluate and ignore LEN in case it has side-effects.  */
11923               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
11924               return expand_expr (dest, target, mode, EXPAND_NORMAL);
11925             }
11926
11927           expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
11928           return expand_expr (expr, target, mode, EXPAND_NORMAL);
11929         }
11930
11931       /* __memmove_chk special case.  */
11932       if (fcode == BUILT_IN_MEMMOVE_CHK)
11933         {
11934           unsigned int src_align
11935             = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
11936
11937           if (src_align == 0)
11938             return NULL_RTX;
11939
11940           /* If src is categorized for a readonly section we can use
11941              normal __memcpy_chk.  */
11942           if (readonly_data_expr (src))
11943             {
11944               tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
11945               if (!fn)
11946                 return NULL_RTX;
11947               fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
11948                                           dest, src, len, size);
11949               gcc_assert (TREE_CODE (fn) == CALL_EXPR);
11950               CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11951               return expand_expr (fn, target, mode, EXPAND_NORMAL);
11952             }
11953         }
11954       return NULL_RTX;
11955     }
11956 }
11957
11958 /* Emit warning if a buffer overflow is detected at compile time.  */
11959
11960 static void
11961 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
11962 {
11963   int is_strlen = 0;
11964   tree len, size;
11965   location_t loc = tree_nonartificial_location (exp);
11966
11967   switch (fcode)
11968     {
11969     case BUILT_IN_STRCPY_CHK:
11970     case BUILT_IN_STPCPY_CHK:
11971     /* For __strcat_chk the warning will be emitted only if overflowing
11972        by at least strlen (dest) + 1 bytes.  */
11973     case BUILT_IN_STRCAT_CHK:
11974       len = CALL_EXPR_ARG (exp, 1);
11975       size = CALL_EXPR_ARG (exp, 2);
11976       is_strlen = 1;
11977       break;
11978     case BUILT_IN_STRNCAT_CHK:
11979     case BUILT_IN_STRNCPY_CHK:
11980       len = CALL_EXPR_ARG (exp, 2);
11981       size = CALL_EXPR_ARG (exp, 3);
11982       break;
11983     case BUILT_IN_SNPRINTF_CHK:
11984     case BUILT_IN_VSNPRINTF_CHK:
11985       len = CALL_EXPR_ARG (exp, 1);
11986       size = CALL_EXPR_ARG (exp, 3);
11987       break;
11988     default:
11989       gcc_unreachable ();
11990     }
11991
11992   if (!len || !size)
11993     return;
11994
11995   if (! host_integerp (size, 1) || integer_all_onesp (size))
11996     return;
11997
11998   if (is_strlen)
11999     {
12000       len = c_strlen (len, 1);
12001       if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12002         return;
12003     }
12004   else if (fcode == BUILT_IN_STRNCAT_CHK)
12005     {
12006       tree src = CALL_EXPR_ARG (exp, 1);
12007       if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12008         return;
12009       src = c_strlen (src, 1);
12010       if (! src || ! host_integerp (src, 1))
12011         {
12012           warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12013                       exp, get_callee_fndecl (exp));
12014           return;
12015         }
12016       else if (tree_int_cst_lt (src, size))
12017         return;
12018     }
12019   else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12020     return;
12021
12022   warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12023               exp, get_callee_fndecl (exp));
12024 }
12025
12026 /* Emit warning if a buffer overflow is detected at compile time
12027    in __sprintf_chk/__vsprintf_chk calls.  */
12028
12029 static void
12030 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12031 {
12032   tree size, len, fmt;
12033   const char *fmt_str;
12034   int nargs = call_expr_nargs (exp);
12035
12036   /* Verify the required arguments in the original call.  */
12037
12038   if (nargs < 4)
12039     return;
12040   size = CALL_EXPR_ARG (exp, 2);
12041   fmt = CALL_EXPR_ARG (exp, 3);
12042
12043   if (! host_integerp (size, 1) || integer_all_onesp (size))
12044     return;
12045
12046   /* Check whether the format is a literal string constant.  */
12047   fmt_str = c_getstr (fmt);
12048   if (fmt_str == NULL)
12049     return;
12050
12051   if (!init_target_chars ())
12052     return;
12053
12054   /* If the format doesn't contain % args or %%, we know its size.  */
12055   if (strchr (fmt_str, target_percent) == 0)
12056     len = build_int_cstu (size_type_node, strlen (fmt_str));
12057   /* If the format is "%s" and first ... argument is a string literal,
12058      we know it too.  */
12059   else if (fcode == BUILT_IN_SPRINTF_CHK
12060            && strcmp (fmt_str, target_percent_s) == 0)
12061     {
12062       tree arg;
12063
12064       if (nargs < 5)
12065         return;
12066       arg = CALL_EXPR_ARG (exp, 4);
12067       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12068         return;
12069
12070       len = c_strlen (arg, 1);
12071       if (!len || ! host_integerp (len, 1))
12072         return;
12073     }
12074   else
12075     return;
12076
12077   if (! tree_int_cst_lt (len, size))
12078     warning_at (tree_nonartificial_location (exp),
12079                 0, "%Kcall to %D will always overflow destination buffer",
12080                 exp, get_callee_fndecl (exp));
12081 }
12082
12083 /* Emit warning if a free is called with address of a variable.  */
12084
12085 static void
12086 maybe_emit_free_warning (tree exp)
12087 {
12088   tree arg = CALL_EXPR_ARG (exp, 0);
12089
12090   STRIP_NOPS (arg);
12091   if (TREE_CODE (arg) != ADDR_EXPR)
12092     return;
12093
12094   arg = get_base_address (TREE_OPERAND (arg, 0));
12095   if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
12096     return;
12097
12098   if (SSA_VAR_P (arg))
12099     warning_at (tree_nonartificial_location (exp),
12100                 0, "%Kattempt to free a non-heap object %qD", exp, arg);
12101   else
12102     warning_at (tree_nonartificial_location (exp),
12103                 0, "%Kattempt to free a non-heap object", exp);
12104 }
12105
12106 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12107    if possible.  */
12108
12109 tree
12110 fold_builtin_object_size (tree ptr, tree ost)
12111 {
12112   unsigned HOST_WIDE_INT bytes;
12113   int object_size_type;
12114
12115   if (!validate_arg (ptr, POINTER_TYPE)
12116       || !validate_arg (ost, INTEGER_TYPE))
12117     return NULL_TREE;
12118
12119   STRIP_NOPS (ost);
12120
12121   if (TREE_CODE (ost) != INTEGER_CST
12122       || tree_int_cst_sgn (ost) < 0
12123       || compare_tree_int (ost, 3) > 0)
12124     return NULL_TREE;
12125
12126   object_size_type = tree_low_cst (ost, 0);
12127
12128   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12129      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12130      and (size_t) 0 for types 2 and 3.  */
12131   if (TREE_SIDE_EFFECTS (ptr))
12132     return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12133
12134   if (TREE_CODE (ptr) == ADDR_EXPR)
12135     {
12136       bytes = compute_builtin_object_size (ptr, object_size_type);
12137       if (double_int_fits_to_tree_p (size_type_node,
12138                                      uhwi_to_double_int (bytes)))
12139         return build_int_cstu (size_type_node, bytes);
12140     }
12141   else if (TREE_CODE (ptr) == SSA_NAME)
12142     {
12143       /* If object size is not known yet, delay folding until
12144        later.  Maybe subsequent passes will help determining
12145        it.  */
12146       bytes = compute_builtin_object_size (ptr, object_size_type);
12147       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
12148           && double_int_fits_to_tree_p (size_type_node,
12149                                         uhwi_to_double_int (bytes)))
12150         return build_int_cstu (size_type_node, bytes);
12151     }
12152
12153   return NULL_TREE;
12154 }
12155
12156 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12157    DEST, SRC, LEN, and SIZE are the arguments to the call.
12158    IGNORE is true, if return value can be ignored.  FCODE is the BUILT_IN_*
12159    code of the builtin.  If MAXLEN is not NULL, it is maximum length
12160    passed as third argument.  */
12161
12162 tree
12163 fold_builtin_memory_chk (location_t loc, tree fndecl,
12164                          tree dest, tree src, tree len, tree size,
12165                          tree maxlen, bool ignore,
12166                          enum built_in_function fcode)
12167 {
12168   tree fn;
12169
12170   if (!validate_arg (dest, POINTER_TYPE)
12171       || !validate_arg (src,
12172                         (fcode == BUILT_IN_MEMSET_CHK
12173                          ? INTEGER_TYPE : POINTER_TYPE))
12174       || !validate_arg (len, INTEGER_TYPE)
12175       || !validate_arg (size, INTEGER_TYPE))
12176     return NULL_TREE;
12177
12178   /* If SRC and DEST are the same (and not volatile), return DEST
12179      (resp. DEST+LEN for __mempcpy_chk).  */
12180   if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12181     {
12182       if (fcode != BUILT_IN_MEMPCPY_CHK)
12183         return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12184                                  dest, len);
12185       else
12186         {
12187           tree temp = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest),
12188                                    dest, len);
12189           return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12190         }
12191     }
12192
12193   if (! host_integerp (size, 1))
12194     return NULL_TREE;
12195
12196   if (! integer_all_onesp (size))
12197     {
12198       if (! host_integerp (len, 1))
12199         {
12200           /* If LEN is not constant, try MAXLEN too.
12201              For MAXLEN only allow optimizing into non-_ocs function
12202              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12203           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12204             {
12205               if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12206                 {
12207                   /* (void) __mempcpy_chk () can be optimized into
12208                      (void) __memcpy_chk ().  */
12209                   fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12210                   if (!fn)
12211                     return NULL_TREE;
12212
12213                   return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12214                 }
12215               return NULL_TREE;
12216             }
12217         }
12218       else
12219         maxlen = len;
12220
12221       if (tree_int_cst_lt (size, maxlen))
12222         return NULL_TREE;
12223     }
12224
12225   fn = NULL_TREE;
12226   /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12227      mem{cpy,pcpy,move,set} is available.  */
12228   switch (fcode)
12229     {
12230     case BUILT_IN_MEMCPY_CHK:
12231       fn = built_in_decls[BUILT_IN_MEMCPY];
12232       break;
12233     case BUILT_IN_MEMPCPY_CHK:
12234       fn = built_in_decls[BUILT_IN_MEMPCPY];
12235       break;
12236     case BUILT_IN_MEMMOVE_CHK:
12237       fn = built_in_decls[BUILT_IN_MEMMOVE];
12238       break;
12239     case BUILT_IN_MEMSET_CHK:
12240       fn = built_in_decls[BUILT_IN_MEMSET];
12241       break;
12242     default:
12243       break;
12244     }
12245
12246   if (!fn)
12247     return NULL_TREE;
12248
12249   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12250 }
12251
12252 /* Fold a call to the __st[rp]cpy_chk builtin.
12253    DEST, SRC, and SIZE are the arguments to the call.
12254    IGNORE is true if return value can be ignored.  FCODE is the BUILT_IN_*
12255    code of the builtin.  If MAXLEN is not NULL, it is maximum length of
12256    strings passed as second argument.  */
12257
12258 tree
12259 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12260                          tree src, tree size,
12261                          tree maxlen, bool ignore,
12262                          enum built_in_function fcode)
12263 {
12264   tree len, fn;
12265
12266   if (!validate_arg (dest, POINTER_TYPE)
12267       || !validate_arg (src, POINTER_TYPE)
12268       || !validate_arg (size, INTEGER_TYPE))
12269     return NULL_TREE;
12270
12271   /* If SRC and DEST are the same (and not volatile), return DEST.  */
12272   if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12273     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12274
12275   if (! host_integerp (size, 1))
12276     return NULL_TREE;
12277
12278   if (! integer_all_onesp (size))
12279     {
12280       len = c_strlen (src, 1);
12281       if (! len || ! host_integerp (len, 1))
12282         {
12283           /* If LEN is not constant, try MAXLEN too.
12284              For MAXLEN only allow optimizing into non-_ocs function
12285              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12286           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12287             {
12288               if (fcode == BUILT_IN_STPCPY_CHK)
12289                 {
12290                   if (! ignore)
12291                     return NULL_TREE;
12292
12293                   /* If return value of __stpcpy_chk is ignored,
12294                      optimize into __strcpy_chk.  */
12295                   fn = built_in_decls[BUILT_IN_STRCPY_CHK];
12296                   if (!fn)
12297                     return NULL_TREE;
12298
12299                   return build_call_expr_loc (loc, fn, 3, dest, src, size);
12300                 }
12301
12302               if (! len || TREE_SIDE_EFFECTS (len))
12303                 return NULL_TREE;
12304
12305               /* If c_strlen returned something, but not a constant,
12306                  transform __strcpy_chk into __memcpy_chk.  */
12307               fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12308               if (!fn)
12309                 return NULL_TREE;
12310
12311               len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
12312               return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12313                                        build_call_expr_loc (loc, fn, 4,
12314                                                         dest, src, len, size));
12315             }
12316         }
12317       else
12318         maxlen = len;
12319
12320       if (! tree_int_cst_lt (maxlen, size))
12321         return NULL_TREE;
12322     }
12323
12324   /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available.  */
12325   fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
12326                       ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
12327   if (!fn)
12328     return NULL_TREE;
12329
12330   return build_call_expr_loc (loc, fn, 2, dest, src);
12331 }
12332
12333 /* Fold a call to the __strncpy_chk builtin.  DEST, SRC, LEN, and SIZE
12334    are the arguments to the call.  If MAXLEN is not NULL, it is maximum
12335    length passed as third argument.  */
12336
12337 tree
12338 fold_builtin_strncpy_chk (location_t loc, tree dest, tree src,
12339                           tree len, tree size, tree maxlen)
12340 {
12341   tree fn;
12342
12343   if (!validate_arg (dest, POINTER_TYPE)
12344       || !validate_arg (src, POINTER_TYPE)
12345       || !validate_arg (len, INTEGER_TYPE)
12346       || !validate_arg (size, INTEGER_TYPE))
12347     return NULL_TREE;
12348
12349   if (! host_integerp (size, 1))
12350     return NULL_TREE;
12351
12352   if (! integer_all_onesp (size))
12353     {
12354       if (! host_integerp (len, 1))
12355         {
12356           /* If LEN is not constant, try MAXLEN too.
12357              For MAXLEN only allow optimizing into non-_ocs function
12358              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12359           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12360             return NULL_TREE;
12361         }
12362       else
12363         maxlen = len;
12364
12365       if (tree_int_cst_lt (size, maxlen))
12366         return NULL_TREE;
12367     }
12368
12369   /* If __builtin_strncpy_chk is used, assume strncpy is available.  */
12370   fn = built_in_decls[BUILT_IN_STRNCPY];
12371   if (!fn)
12372     return NULL_TREE;
12373
12374   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12375 }
12376
12377 /* Fold a call to the __strcat_chk builtin FNDECL.  DEST, SRC, and SIZE
12378    are the arguments to the call.  */
12379
12380 static tree
12381 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12382                          tree src, tree size)
12383 {
12384   tree fn;
12385   const char *p;
12386
12387   if (!validate_arg (dest, POINTER_TYPE)
12388       || !validate_arg (src, POINTER_TYPE)
12389       || !validate_arg (size, INTEGER_TYPE))
12390     return NULL_TREE;
12391
12392   p = c_getstr (src);
12393   /* If the SRC parameter is "", return DEST.  */
12394   if (p && *p == '\0')
12395     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12396
12397   if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12398     return NULL_TREE;
12399
12400   /* If __builtin_strcat_chk is used, assume strcat is available.  */
12401   fn = built_in_decls[BUILT_IN_STRCAT];
12402   if (!fn)
12403     return NULL_TREE;
12404
12405   return build_call_expr_loc (loc, fn, 2, dest, src);
12406 }
12407
12408 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12409    LEN, and SIZE.  */
12410
12411 static tree
12412 fold_builtin_strncat_chk (location_t loc, tree fndecl,
12413                           tree dest, tree src, tree len, tree size)
12414 {
12415   tree fn;
12416   const char *p;
12417
12418   if (!validate_arg (dest, POINTER_TYPE)
12419       || !validate_arg (src, POINTER_TYPE)
12420       || !validate_arg (size, INTEGER_TYPE)
12421       || !validate_arg (size, INTEGER_TYPE))
12422     return NULL_TREE;
12423
12424   p = c_getstr (src);
12425   /* If the SRC parameter is "" or if LEN is 0, return DEST.  */
12426   if (p && *p == '\0')
12427     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12428   else if (integer_zerop (len))
12429     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12430
12431   if (! host_integerp (size, 1))
12432     return NULL_TREE;
12433
12434   if (! integer_all_onesp (size))
12435     {
12436       tree src_len = c_strlen (src, 1);
12437       if (src_len
12438           && host_integerp (src_len, 1)
12439           && host_integerp (len, 1)
12440           && ! tree_int_cst_lt (len, src_len))
12441         {
12442           /* If LEN >= strlen (SRC), optimize into __strcat_chk.  */
12443           fn = built_in_decls[BUILT_IN_STRCAT_CHK];
12444           if (!fn)
12445             return NULL_TREE;
12446
12447           return build_call_expr_loc (loc, fn, 3, dest, src, size);
12448         }
12449       return NULL_TREE;
12450     }
12451
12452   /* If __builtin_strncat_chk is used, assume strncat is available.  */
12453   fn = built_in_decls[BUILT_IN_STRNCAT];
12454   if (!fn)
12455     return NULL_TREE;
12456
12457   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12458 }
12459
12460 /* Fold a call EXP to __{,v}sprintf_chk.  Return NULL_TREE if
12461    a normal call should be emitted rather than expanding the function
12462    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
12463
12464 static tree
12465 fold_builtin_sprintf_chk (location_t loc, tree exp,
12466                           enum built_in_function fcode)
12467 {
12468   tree dest, size, len, fn, fmt, flag;
12469   const char *fmt_str;
12470   int nargs = call_expr_nargs (exp);
12471
12472   /* Verify the required arguments in the original call.  */
12473   if (nargs < 4)
12474     return NULL_TREE;
12475   dest = CALL_EXPR_ARG (exp, 0);
12476   if (!validate_arg (dest, POINTER_TYPE))
12477     return NULL_TREE;
12478   flag = CALL_EXPR_ARG (exp, 1);
12479   if (!validate_arg (flag, INTEGER_TYPE))
12480     return NULL_TREE;
12481   size = CALL_EXPR_ARG (exp, 2);
12482   if (!validate_arg (size, INTEGER_TYPE))
12483     return NULL_TREE;
12484   fmt = CALL_EXPR_ARG (exp, 3);
12485   if (!validate_arg (fmt, POINTER_TYPE))
12486     return NULL_TREE;
12487
12488   if (! host_integerp (size, 1))
12489     return NULL_TREE;
12490
12491   len = NULL_TREE;
12492
12493   if (!init_target_chars ())
12494     return NULL_TREE;
12495
12496   /* Check whether the format is a literal string constant.  */
12497   fmt_str = c_getstr (fmt);
12498   if (fmt_str != NULL)
12499     {
12500       /* If the format doesn't contain % args or %%, we know the size.  */
12501       if (strchr (fmt_str, target_percent) == 0)
12502         {
12503           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
12504             len = build_int_cstu (size_type_node, strlen (fmt_str));
12505         }
12506       /* If the format is "%s" and first ... argument is a string literal,
12507          we know the size too.  */
12508       else if (fcode == BUILT_IN_SPRINTF_CHK
12509                && strcmp (fmt_str, target_percent_s) == 0)
12510         {
12511           tree arg;
12512
12513           if (nargs == 5)
12514             {
12515               arg = CALL_EXPR_ARG (exp, 4);
12516               if (validate_arg (arg, POINTER_TYPE))
12517                 {
12518                   len = c_strlen (arg, 1);
12519                   if (! len || ! host_integerp (len, 1))
12520                     len = NULL_TREE;
12521                 }
12522             }
12523         }
12524     }
12525
12526   if (! integer_all_onesp (size))
12527     {
12528       if (! len || ! tree_int_cst_lt (len, size))
12529         return NULL_TREE;
12530     }
12531
12532   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12533      or if format doesn't contain % chars or is "%s".  */
12534   if (! integer_zerop (flag))
12535     {
12536       if (fmt_str == NULL)
12537         return NULL_TREE;
12538       if (strchr (fmt_str, target_percent) != NULL
12539           && strcmp (fmt_str, target_percent_s))
12540         return NULL_TREE;
12541     }
12542
12543   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
12544   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
12545                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
12546   if (!fn)
12547     return NULL_TREE;
12548
12549   return rewrite_call_expr (loc, exp, 4, fn, 2, dest, fmt);
12550 }
12551
12552 /* Fold a call EXP to {,v}snprintf.  Return NULL_TREE if
12553    a normal call should be emitted rather than expanding the function
12554    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
12555    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
12556    passed as second argument.  */
12557
12558 tree
12559 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
12560                            enum built_in_function fcode)
12561 {
12562   tree dest, size, len, fn, fmt, flag;
12563   const char *fmt_str;
12564
12565   /* Verify the required arguments in the original call.  */
12566   if (call_expr_nargs (exp) < 5)
12567     return NULL_TREE;
12568   dest = CALL_EXPR_ARG (exp, 0);
12569   if (!validate_arg (dest, POINTER_TYPE))
12570     return NULL_TREE;
12571   len = CALL_EXPR_ARG (exp, 1);
12572   if (!validate_arg (len, INTEGER_TYPE))
12573     return NULL_TREE;
12574   flag = CALL_EXPR_ARG (exp, 2);
12575   if (!validate_arg (flag, INTEGER_TYPE))
12576     return NULL_TREE;
12577   size = CALL_EXPR_ARG (exp, 3);
12578   if (!validate_arg (size, INTEGER_TYPE))
12579     return NULL_TREE;
12580   fmt = CALL_EXPR_ARG (exp, 4);
12581   if (!validate_arg (fmt, POINTER_TYPE))
12582     return NULL_TREE;
12583
12584   if (! host_integerp (size, 1))
12585     return NULL_TREE;
12586
12587   if (! integer_all_onesp (size))
12588     {
12589       if (! host_integerp (len, 1))
12590         {
12591           /* If LEN is not constant, try MAXLEN too.
12592              For MAXLEN only allow optimizing into non-_ocs function
12593              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12594           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12595             return NULL_TREE;
12596         }
12597       else
12598         maxlen = len;
12599
12600       if (tree_int_cst_lt (size, maxlen))
12601         return NULL_TREE;
12602     }
12603
12604   if (!init_target_chars ())
12605     return NULL_TREE;
12606
12607   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12608      or if format doesn't contain % chars or is "%s".  */
12609   if (! integer_zerop (flag))
12610     {
12611       fmt_str = c_getstr (fmt);
12612       if (fmt_str == NULL)
12613         return NULL_TREE;
12614       if (strchr (fmt_str, target_percent) != NULL
12615           && strcmp (fmt_str, target_percent_s))
12616         return NULL_TREE;
12617     }
12618
12619   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12620      available.  */
12621   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
12622                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
12623   if (!fn)
12624     return NULL_TREE;
12625
12626   return rewrite_call_expr (loc, exp, 5, fn, 3, dest, len, fmt);
12627 }
12628
12629 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12630    FMT and ARG are the arguments to the call; we don't fold cases with
12631    more than 2 arguments, and ARG may be null if this is a 1-argument case.
12632
12633    Return NULL_TREE if no simplification was possible, otherwise return the
12634    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12635    code of the function to be simplified.  */
12636
12637 static tree
12638 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
12639                      tree arg, bool ignore,
12640                      enum built_in_function fcode)
12641 {
12642   tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
12643   const char *fmt_str = NULL;
12644
12645   /* If the return value is used, don't do the transformation.  */
12646   if (! ignore)
12647     return NULL_TREE;
12648
12649   /* Verify the required arguments in the original call.  */
12650   if (!validate_arg (fmt, POINTER_TYPE))
12651     return NULL_TREE;
12652
12653   /* Check whether the format is a literal string constant.  */
12654   fmt_str = c_getstr (fmt);
12655   if (fmt_str == NULL)
12656     return NULL_TREE;
12657
12658   if (fcode == BUILT_IN_PRINTF_UNLOCKED)
12659     {
12660       /* If we're using an unlocked function, assume the other
12661          unlocked functions exist explicitly.  */
12662       fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
12663       fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
12664     }
12665   else
12666     {
12667       fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
12668       fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
12669     }
12670
12671   if (!init_target_chars ())
12672     return NULL_TREE;
12673
12674   if (strcmp (fmt_str, target_percent_s) == 0
12675       || strchr (fmt_str, target_percent) == NULL)
12676     {
12677       const char *str;
12678
12679       if (strcmp (fmt_str, target_percent_s) == 0)
12680         {
12681           if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12682             return NULL_TREE;
12683
12684           if (!arg || !validate_arg (arg, POINTER_TYPE))
12685             return NULL_TREE;
12686
12687           str = c_getstr (arg);
12688           if (str == NULL)
12689             return NULL_TREE;
12690         }
12691       else
12692         {
12693           /* The format specifier doesn't contain any '%' characters.  */
12694           if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
12695               && arg)
12696             return NULL_TREE;
12697           str = fmt_str;
12698         }
12699
12700       /* If the string was "", printf does nothing.  */
12701       if (str[0] == '\0')
12702         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12703
12704       /* If the string has length of 1, call putchar.  */
12705       if (str[1] == '\0')
12706         {
12707           /* Given printf("c"), (where c is any one character,)
12708              convert "c"[0] to an int and pass that to the replacement
12709              function.  */
12710           newarg = build_int_cst (NULL_TREE, str[0]);
12711           if (fn_putchar)
12712             call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
12713         }
12714       else
12715         {
12716           /* If the string was "string\n", call puts("string").  */
12717           size_t len = strlen (str);
12718           if ((unsigned char)str[len - 1] == target_newline)
12719             {
12720               /* Create a NUL-terminated string that's one char shorter
12721                  than the original, stripping off the trailing '\n'.  */
12722               char *newstr = XALLOCAVEC (char, len);
12723               memcpy (newstr, str, len - 1);
12724               newstr[len - 1] = 0;
12725
12726               newarg = build_string_literal (len, newstr);
12727               if (fn_puts)
12728                 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
12729             }
12730           else
12731             /* We'd like to arrange to call fputs(string,stdout) here,
12732                but we need stdout and don't have a way to get it yet.  */
12733             return NULL_TREE;
12734         }
12735     }
12736
12737   /* The other optimizations can be done only on the non-va_list variants.  */
12738   else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12739     return NULL_TREE;
12740
12741   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
12742   else if (strcmp (fmt_str, target_percent_s_newline) == 0)
12743     {
12744       if (!arg || !validate_arg (arg, POINTER_TYPE))
12745         return NULL_TREE;
12746       if (fn_puts)
12747         call = build_call_expr_loc (loc, fn_puts, 1, arg);
12748     }
12749
12750   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
12751   else if (strcmp (fmt_str, target_percent_c) == 0)
12752     {
12753       if (!arg || !validate_arg (arg, INTEGER_TYPE))
12754         return NULL_TREE;
12755       if (fn_putchar)
12756         call = build_call_expr_loc (loc, fn_putchar, 1, arg);
12757     }
12758
12759   if (!call)
12760     return NULL_TREE;
12761
12762   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12763 }
12764
12765 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
12766    FP, FMT, and ARG are the arguments to the call.  We don't fold calls with
12767    more than 3 arguments, and ARG may be null in the 2-argument case.
12768
12769    Return NULL_TREE if no simplification was possible, otherwise return the
12770    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12771    code of the function to be simplified.  */
12772
12773 static tree
12774 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
12775                       tree fmt, tree arg, bool ignore,
12776                       enum built_in_function fcode)
12777 {
12778   tree fn_fputc, fn_fputs, call = NULL_TREE;
12779   const char *fmt_str = NULL;
12780
12781   /* If the return value is used, don't do the transformation.  */
12782   if (! ignore)
12783     return NULL_TREE;
12784
12785   /* Verify the required arguments in the original call.  */
12786   if (!validate_arg (fp, POINTER_TYPE))
12787     return NULL_TREE;
12788   if (!validate_arg (fmt, POINTER_TYPE))
12789     return NULL_TREE;
12790
12791   /* Check whether the format is a literal string constant.  */
12792   fmt_str = c_getstr (fmt);
12793   if (fmt_str == NULL)
12794     return NULL_TREE;
12795
12796   if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
12797     {
12798       /* If we're using an unlocked function, assume the other
12799          unlocked functions exist explicitly.  */
12800       fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
12801       fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
12802     }
12803   else
12804     {
12805       fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
12806       fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
12807     }
12808
12809   if (!init_target_chars ())
12810     return NULL_TREE;
12811
12812   /* If the format doesn't contain % args or %%, use strcpy.  */
12813   if (strchr (fmt_str, target_percent) == NULL)
12814     {
12815       if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
12816           && arg)
12817         return NULL_TREE;
12818
12819       /* If the format specifier was "", fprintf does nothing.  */
12820       if (fmt_str[0] == '\0')
12821         {
12822           /* If FP has side-effects, just wait until gimplification is
12823              done.  */
12824           if (TREE_SIDE_EFFECTS (fp))
12825             return NULL_TREE;
12826
12827           return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12828         }
12829
12830       /* When "string" doesn't contain %, replace all cases of
12831          fprintf (fp, string) with fputs (string, fp).  The fputs
12832          builtin will take care of special cases like length == 1.  */
12833       if (fn_fputs)
12834         call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
12835     }
12836
12837   /* The other optimizations can be done only on the non-va_list variants.  */
12838   else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
12839     return NULL_TREE;
12840
12841   /* If the format specifier was "%s", call __builtin_fputs (arg, fp).  */
12842   else if (strcmp (fmt_str, target_percent_s) == 0)
12843     {
12844       if (!arg || !validate_arg (arg, POINTER_TYPE))
12845         return NULL_TREE;
12846       if (fn_fputs)
12847         call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
12848     }
12849
12850   /* If the format specifier was "%c", call __builtin_fputc (arg, fp).  */
12851   else if (strcmp (fmt_str, target_percent_c) == 0)
12852     {
12853       if (!arg || !validate_arg (arg, INTEGER_TYPE))
12854         return NULL_TREE;
12855       if (fn_fputc)
12856         call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
12857     }
12858
12859   if (!call)
12860     return NULL_TREE;
12861   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12862 }
12863
12864 /* Initialize format string characters in the target charset.  */
12865
12866 static bool
12867 init_target_chars (void)
12868 {
12869   static bool init;
12870   if (!init)
12871     {
12872       target_newline = lang_hooks.to_target_charset ('\n');
12873       target_percent = lang_hooks.to_target_charset ('%');
12874       target_c = lang_hooks.to_target_charset ('c');
12875       target_s = lang_hooks.to_target_charset ('s');
12876       if (target_newline == 0 || target_percent == 0 || target_c == 0
12877           || target_s == 0)
12878         return false;
12879
12880       target_percent_c[0] = target_percent;
12881       target_percent_c[1] = target_c;
12882       target_percent_c[2] = '\0';
12883
12884       target_percent_s[0] = target_percent;
12885       target_percent_s[1] = target_s;
12886       target_percent_s[2] = '\0';
12887
12888       target_percent_s_newline[0] = target_percent;
12889       target_percent_s_newline[1] = target_s;
12890       target_percent_s_newline[2] = target_newline;
12891       target_percent_s_newline[3] = '\0';
12892
12893       init = true;
12894     }
12895   return true;
12896 }
12897
12898 /* Helper function for do_mpfr_arg*().  Ensure M is a normal number
12899    and no overflow/underflow occurred.  INEXACT is true if M was not
12900    exactly calculated.  TYPE is the tree type for the result.  This
12901    function assumes that you cleared the MPFR flags and then
12902    calculated M to see if anything subsequently set a flag prior to
12903    entering this function.  Return NULL_TREE if any checks fail.  */
12904
12905 static tree
12906 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
12907 {
12908   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12909      overflow/underflow occurred.  If -frounding-math, proceed iff the
12910      result of calling FUNC was exact.  */
12911   if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
12912       && (!flag_rounding_math || !inexact))
12913     {
12914       REAL_VALUE_TYPE rr;
12915
12916       real_from_mpfr (&rr, m, type, GMP_RNDN);
12917       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
12918          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
12919          but the mpft_t is not, then we underflowed in the
12920          conversion.  */
12921       if (real_isfinite (&rr)
12922           && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
12923         {
12924           REAL_VALUE_TYPE rmode;
12925
12926           real_convert (&rmode, TYPE_MODE (type), &rr);
12927           /* Proceed iff the specified mode can hold the value.  */
12928           if (real_identical (&rmode, &rr))
12929             return build_real (type, rmode);
12930         }
12931     }
12932   return NULL_TREE;
12933 }
12934
12935 /* Helper function for do_mpc_arg*().  Ensure M is a normal complex
12936    number and no overflow/underflow occurred.  INEXACT is true if M
12937    was not exactly calculated.  TYPE is the tree type for the result.
12938    This function assumes that you cleared the MPFR flags and then
12939    calculated M to see if anything subsequently set a flag prior to
12940    entering this function.  Return NULL_TREE if any checks fail, if
12941    FORCE_CONVERT is true, then bypass the checks.  */
12942
12943 static tree
12944 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
12945 {
12946   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12947      overflow/underflow occurred.  If -frounding-math, proceed iff the
12948      result of calling FUNC was exact.  */
12949   if (force_convert
12950       || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
12951           && !mpfr_overflow_p () && !mpfr_underflow_p ()
12952           && (!flag_rounding_math || !inexact)))
12953     {
12954       REAL_VALUE_TYPE re, im;
12955
12956       real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
12957       real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
12958       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
12959          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
12960          but the mpft_t is not, then we underflowed in the
12961          conversion.  */
12962       if (force_convert
12963           || (real_isfinite (&re) && real_isfinite (&im)
12964               && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
12965               && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
12966         {
12967           REAL_VALUE_TYPE re_mode, im_mode;
12968
12969           real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
12970           real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
12971           /* Proceed iff the specified mode can hold the value.  */
12972           if (force_convert
12973               || (real_identical (&re_mode, &re)
12974                   && real_identical (&im_mode, &im)))
12975             return build_complex (type, build_real (TREE_TYPE (type), re_mode),
12976                                   build_real (TREE_TYPE (type), im_mode));
12977         }
12978     }
12979   return NULL_TREE;
12980 }
12981
12982 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
12983    FUNC on it and return the resulting value as a tree with type TYPE.
12984    If MIN and/or MAX are not NULL, then the supplied ARG must be
12985    within those bounds.  If INCLUSIVE is true, then MIN/MAX are
12986    acceptable values, otherwise they are not.  The mpfr precision is
12987    set to the precision of TYPE.  We assume that function FUNC returns
12988    zero if the result could be calculated exactly within the requested
12989    precision.  */
12990
12991 static tree
12992 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
12993               const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
12994               bool inclusive)
12995 {
12996   tree result = NULL_TREE;
12997
12998   STRIP_NOPS (arg);
12999
13000   /* To proceed, MPFR must exactly represent the target floating point
13001      format, which only happens when the target base equals two.  */
13002   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13003       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13004     {
13005       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13006
13007       if (real_isfinite (ra)
13008           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13009           && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13010         {
13011           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13012           const int prec = fmt->p;
13013           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13014           int inexact;
13015           mpfr_t m;
13016
13017           mpfr_init2 (m, prec);
13018           mpfr_from_real (m, ra, GMP_RNDN);
13019           mpfr_clear_flags ();
13020           inexact = func (m, m, rnd);
13021           result = do_mpfr_ckconv (m, type, inexact);
13022           mpfr_clear (m);
13023         }
13024     }
13025
13026   return result;
13027 }
13028
13029 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13030    FUNC on it and return the resulting value as a tree with type TYPE.
13031    The mpfr precision is set to the precision of TYPE.  We assume that
13032    function FUNC returns zero if the result could be calculated
13033    exactly within the requested precision.  */
13034
13035 static tree
13036 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13037               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13038 {
13039   tree result = NULL_TREE;
13040
13041   STRIP_NOPS (arg1);
13042   STRIP_NOPS (arg2);
13043
13044   /* To proceed, MPFR must exactly represent the target floating point
13045      format, which only happens when the target base equals two.  */
13046   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13047       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13048       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13049     {
13050       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13051       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13052
13053       if (real_isfinite (ra1) && real_isfinite (ra2))
13054         {
13055           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13056           const int prec = fmt->p;
13057           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13058           int inexact;
13059           mpfr_t m1, m2;
13060
13061           mpfr_inits2 (prec, m1, m2, NULL);
13062           mpfr_from_real (m1, ra1, GMP_RNDN);
13063           mpfr_from_real (m2, ra2, GMP_RNDN);
13064           mpfr_clear_flags ();
13065           inexact = func (m1, m1, m2, rnd);
13066           result = do_mpfr_ckconv (m1, type, inexact);
13067           mpfr_clears (m1, m2, NULL);
13068         }
13069     }
13070
13071   return result;
13072 }
13073
13074 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13075    FUNC on it and return the resulting value as a tree with type TYPE.
13076    The mpfr precision is set to the precision of TYPE.  We assume that
13077    function FUNC returns zero if the result could be calculated
13078    exactly within the requested precision.  */
13079
13080 static tree
13081 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13082               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13083 {
13084   tree result = NULL_TREE;
13085
13086   STRIP_NOPS (arg1);
13087   STRIP_NOPS (arg2);
13088   STRIP_NOPS (arg3);
13089
13090   /* To proceed, MPFR must exactly represent the target floating point
13091      format, which only happens when the target base equals two.  */
13092   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13093       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13094       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13095       && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13096     {
13097       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13098       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13099       const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13100
13101       if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13102         {
13103           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13104           const int prec = fmt->p;
13105           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13106           int inexact;
13107           mpfr_t m1, m2, m3;
13108
13109           mpfr_inits2 (prec, m1, m2, m3, NULL);
13110           mpfr_from_real (m1, ra1, GMP_RNDN);
13111           mpfr_from_real (m2, ra2, GMP_RNDN);
13112           mpfr_from_real (m3, ra3, GMP_RNDN);
13113           mpfr_clear_flags ();
13114           inexact = func (m1, m1, m2, m3, rnd);
13115           result = do_mpfr_ckconv (m1, type, inexact);
13116           mpfr_clears (m1, m2, m3, NULL);
13117         }
13118     }
13119
13120   return result;
13121 }
13122
13123 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13124    the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13125    If ARG_SINP and ARG_COSP are NULL then the result is returned
13126    as a complex value.
13127    The type is taken from the type of ARG and is used for setting the
13128    precision of the calculation and results.  */
13129
13130 static tree
13131 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13132 {
13133   tree const type = TREE_TYPE (arg);
13134   tree result = NULL_TREE;
13135
13136   STRIP_NOPS (arg);
13137
13138   /* To proceed, MPFR must exactly represent the target floating point
13139      format, which only happens when the target base equals two.  */
13140   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13141       && TREE_CODE (arg) == REAL_CST
13142       && !TREE_OVERFLOW (arg))
13143     {
13144       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13145
13146       if (real_isfinite (ra))
13147         {
13148           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13149           const int prec = fmt->p;
13150           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13151           tree result_s, result_c;
13152           int inexact;
13153           mpfr_t m, ms, mc;
13154
13155           mpfr_inits2 (prec, m, ms, mc, NULL);
13156           mpfr_from_real (m, ra, GMP_RNDN);
13157           mpfr_clear_flags ();
13158           inexact = mpfr_sin_cos (ms, mc, m, rnd);
13159           result_s = do_mpfr_ckconv (ms, type, inexact);
13160           result_c = do_mpfr_ckconv (mc, type, inexact);
13161           mpfr_clears (m, ms, mc, NULL);
13162           if (result_s && result_c)
13163             {
13164               /* If we are to return in a complex value do so.  */
13165               if (!arg_sinp && !arg_cosp)
13166                 return build_complex (build_complex_type (type),
13167                                       result_c, result_s);
13168
13169               /* Dereference the sin/cos pointer arguments.  */
13170               arg_sinp = build_fold_indirect_ref (arg_sinp);
13171               arg_cosp = build_fold_indirect_ref (arg_cosp);
13172               /* Proceed if valid pointer type were passed in.  */
13173               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13174                   && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13175                 {
13176                   /* Set the values. */
13177                   result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13178                                           result_s);
13179                   TREE_SIDE_EFFECTS (result_s) = 1;
13180                   result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13181                                           result_c);
13182                   TREE_SIDE_EFFECTS (result_c) = 1;
13183                   /* Combine the assignments into a compound expr.  */
13184                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13185                                                     result_s, result_c));
13186                 }
13187             }
13188         }
13189     }
13190   return result;
13191 }
13192
13193 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13194    two-argument mpfr order N Bessel function FUNC on them and return
13195    the resulting value as a tree with type TYPE.  The mpfr precision
13196    is set to the precision of TYPE.  We assume that function FUNC
13197    returns zero if the result could be calculated exactly within the
13198    requested precision.  */
13199 static tree
13200 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13201                   int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13202                   const REAL_VALUE_TYPE *min, bool inclusive)
13203 {
13204   tree result = NULL_TREE;
13205
13206   STRIP_NOPS (arg1);
13207   STRIP_NOPS (arg2);
13208
13209   /* To proceed, MPFR must exactly represent the target floating point
13210      format, which only happens when the target base equals two.  */
13211   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13212       && host_integerp (arg1, 0)
13213       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13214     {
13215       const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13216       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13217
13218       if (n == (long)n
13219           && real_isfinite (ra)
13220           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13221         {
13222           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13223           const int prec = fmt->p;
13224           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13225           int inexact;
13226           mpfr_t m;
13227
13228           mpfr_init2 (m, prec);
13229           mpfr_from_real (m, ra, GMP_RNDN);
13230           mpfr_clear_flags ();
13231           inexact = func (m, n, m, rnd);
13232           result = do_mpfr_ckconv (m, type, inexact);
13233           mpfr_clear (m);
13234         }
13235     }
13236
13237   return result;
13238 }
13239
13240 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13241    the pointer *(ARG_QUO) and return the result.  The type is taken
13242    from the type of ARG0 and is used for setting the precision of the
13243    calculation and results.  */
13244
13245 static tree
13246 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13247 {
13248   tree const type = TREE_TYPE (arg0);
13249   tree result = NULL_TREE;
13250
13251   STRIP_NOPS (arg0);
13252   STRIP_NOPS (arg1);
13253
13254   /* To proceed, MPFR must exactly represent the target floating point
13255      format, which only happens when the target base equals two.  */
13256   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13257       && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13258       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13259     {
13260       const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13261       const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13262
13263       if (real_isfinite (ra0) && real_isfinite (ra1))
13264         {
13265           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13266           const int prec = fmt->p;
13267           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13268           tree result_rem;
13269           long integer_quo;
13270           mpfr_t m0, m1;
13271
13272           mpfr_inits2 (prec, m0, m1, NULL);
13273           mpfr_from_real (m0, ra0, GMP_RNDN);
13274           mpfr_from_real (m1, ra1, GMP_RNDN);
13275           mpfr_clear_flags ();
13276           mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13277           /* Remquo is independent of the rounding mode, so pass
13278              inexact=0 to do_mpfr_ckconv().  */
13279           result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13280           mpfr_clears (m0, m1, NULL);
13281           if (result_rem)
13282             {
13283               /* MPFR calculates quo in the host's long so it may
13284                  return more bits in quo than the target int can hold
13285                  if sizeof(host long) > sizeof(target int).  This can
13286                  happen even for native compilers in LP64 mode.  In
13287                  these cases, modulo the quo value with the largest
13288                  number that the target int can hold while leaving one
13289                  bit for the sign.  */
13290               if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13291                 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13292
13293               /* Dereference the quo pointer argument.  */
13294               arg_quo = build_fold_indirect_ref (arg_quo);
13295               /* Proceed iff a valid pointer type was passed in.  */
13296               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13297                 {
13298                   /* Set the value. */
13299                   tree result_quo = fold_build2 (MODIFY_EXPR,
13300                                                  TREE_TYPE (arg_quo), arg_quo,
13301                                                  build_int_cst (NULL, integer_quo));
13302                   TREE_SIDE_EFFECTS (result_quo) = 1;
13303                   /* Combine the quo assignment with the rem.  */
13304                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13305                                                     result_quo, result_rem));
13306                 }
13307             }
13308         }
13309     }
13310   return result;
13311 }
13312
13313 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13314    resulting value as a tree with type TYPE.  The mpfr precision is
13315    set to the precision of TYPE.  We assume that this mpfr function
13316    returns zero if the result could be calculated exactly within the
13317    requested precision.  In addition, the integer pointer represented
13318    by ARG_SG will be dereferenced and set to the appropriate signgam
13319    (-1,1) value.  */
13320
13321 static tree
13322 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13323 {
13324   tree result = NULL_TREE;
13325
13326   STRIP_NOPS (arg);
13327
13328   /* To proceed, MPFR must exactly represent the target floating point
13329      format, which only happens when the target base equals two.  Also
13330      verify ARG is a constant and that ARG_SG is an int pointer.  */
13331   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13332       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13333       && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13334       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13335     {
13336       const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13337
13338       /* In addition to NaN and Inf, the argument cannot be zero or a
13339          negative integer.  */
13340       if (real_isfinite (ra)
13341           && ra->cl != rvc_zero
13342           && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13343         {
13344           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13345           const int prec = fmt->p;
13346           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13347           int inexact, sg;
13348           mpfr_t m;
13349           tree result_lg;
13350
13351           mpfr_init2 (m, prec);
13352           mpfr_from_real (m, ra, GMP_RNDN);
13353           mpfr_clear_flags ();
13354           inexact = mpfr_lgamma (m, &sg, m, rnd);
13355           result_lg = do_mpfr_ckconv (m, type, inexact);
13356           mpfr_clear (m);
13357           if (result_lg)
13358             {
13359               tree result_sg;
13360
13361               /* Dereference the arg_sg pointer argument.  */
13362               arg_sg = build_fold_indirect_ref (arg_sg);
13363               /* Assign the signgam value into *arg_sg. */
13364               result_sg = fold_build2 (MODIFY_EXPR,
13365                                        TREE_TYPE (arg_sg), arg_sg,
13366                                        build_int_cst (NULL, sg));
13367               TREE_SIDE_EFFECTS (result_sg) = 1;
13368               /* Combine the signgam assignment with the lgamma result.  */
13369               result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13370                                                 result_sg, result_lg));
13371             }
13372         }
13373     }
13374
13375   return result;
13376 }
13377
13378 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13379    function FUNC on it and return the resulting value as a tree with
13380    type TYPE.  The mpfr precision is set to the precision of TYPE.  We
13381    assume that function FUNC returns zero if the result could be
13382    calculated exactly within the requested precision.  */
13383
13384 static tree
13385 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13386 {
13387   tree result = NULL_TREE;
13388
13389   STRIP_NOPS (arg);
13390
13391   /* To proceed, MPFR must exactly represent the target floating point
13392      format, which only happens when the target base equals two.  */
13393   if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
13394       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
13395       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
13396     {
13397       const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
13398       const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
13399
13400       if (real_isfinite (re) && real_isfinite (im))
13401         {
13402           const struct real_format *const fmt =
13403             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13404           const int prec = fmt->p;
13405           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13406           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13407           int inexact;
13408           mpc_t m;
13409
13410           mpc_init2 (m, prec);
13411           mpfr_from_real (mpc_realref(m), re, rnd);
13412           mpfr_from_real (mpc_imagref(m), im, rnd);
13413           mpfr_clear_flags ();
13414           inexact = func (m, m, crnd);
13415           result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
13416           mpc_clear (m);
13417         }
13418     }
13419
13420   return result;
13421 }
13422
13423 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
13424    mpc function FUNC on it and return the resulting value as a tree
13425    with type TYPE.  The mpfr precision is set to the precision of
13426    TYPE.  We assume that function FUNC returns zero if the result
13427    could be calculated exactly within the requested precision.  If
13428    DO_NONFINITE is true, then fold expressions containing Inf or NaN
13429    in the arguments and/or results.  */
13430
13431 tree
13432 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
13433              int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
13434 {
13435   tree result = NULL_TREE;
13436
13437   STRIP_NOPS (arg0);
13438   STRIP_NOPS (arg1);
13439
13440   /* To proceed, MPFR must exactly represent the target floating point
13441      format, which only happens when the target base equals two.  */
13442   if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
13443       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
13444       && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
13445       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
13446       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
13447     {
13448       const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
13449       const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
13450       const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
13451       const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
13452
13453       if (do_nonfinite
13454           || (real_isfinite (re0) && real_isfinite (im0)
13455               && real_isfinite (re1) && real_isfinite (im1)))
13456         {
13457           const struct real_format *const fmt =
13458             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13459           const int prec = fmt->p;
13460           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13461           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13462           int inexact;
13463           mpc_t m0, m1;
13464
13465           mpc_init2 (m0, prec);
13466           mpc_init2 (m1, prec);
13467           mpfr_from_real (mpc_realref(m0), re0, rnd);
13468           mpfr_from_real (mpc_imagref(m0), im0, rnd);
13469           mpfr_from_real (mpc_realref(m1), re1, rnd);
13470           mpfr_from_real (mpc_imagref(m1), im1, rnd);
13471           mpfr_clear_flags ();
13472           inexact = func (m0, m0, m1, crnd);
13473           result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
13474           mpc_clear (m0);
13475           mpc_clear (m1);
13476         }
13477     }
13478
13479   return result;
13480 }
13481
13482 /* FIXME tuples.
13483    The functions below provide an alternate interface for folding
13484    builtin function calls presented as GIMPLE_CALL statements rather
13485    than as CALL_EXPRs.  The folded result is still expressed as a
13486    tree.  There is too much code duplication in the handling of
13487    varargs functions, and a more intrusive re-factoring would permit
13488    better sharing of code between the tree and statement-based
13489    versions of these functions.  */
13490
13491 /* Construct a new CALL_EXPR using the tail of the argument list of STMT
13492    along with N new arguments specified as the "..." parameters.  SKIP
13493    is the number of arguments in STMT to be omitted.  This function is used
13494    to do varargs-to-varargs transformations.  */
13495
13496 static tree
13497 gimple_rewrite_call_expr (gimple stmt, int skip, tree fndecl, int n, ...)
13498 {
13499   int oldnargs = gimple_call_num_args (stmt);
13500   int nargs = oldnargs - skip + n;
13501   tree fntype = TREE_TYPE (fndecl);
13502   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
13503   tree *buffer;
13504   int i, j;
13505   va_list ap;
13506   location_t loc = gimple_location (stmt);
13507
13508   buffer = XALLOCAVEC (tree, nargs);
13509   va_start (ap, n);
13510   for (i = 0; i < n; i++)
13511     buffer[i] = va_arg (ap, tree);
13512   va_end (ap);
13513   for (j = skip; j < oldnargs; j++, i++)
13514     buffer[i] = gimple_call_arg (stmt, j);
13515
13516   return fold (build_call_array_loc (loc, TREE_TYPE (fntype), fn, nargs, buffer));
13517 }
13518
13519 /* Fold a call STMT to __{,v}sprintf_chk.  Return NULL_TREE if
13520    a normal call should be emitted rather than expanding the function
13521    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
13522
13523 static tree
13524 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
13525 {
13526   tree dest, size, len, fn, fmt, flag;
13527   const char *fmt_str;
13528   int nargs = gimple_call_num_args (stmt);
13529
13530   /* Verify the required arguments in the original call.  */
13531   if (nargs < 4)
13532     return NULL_TREE;
13533   dest = gimple_call_arg (stmt, 0);
13534   if (!validate_arg (dest, POINTER_TYPE))
13535     return NULL_TREE;
13536   flag = gimple_call_arg (stmt, 1);
13537   if (!validate_arg (flag, INTEGER_TYPE))
13538     return NULL_TREE;
13539   size = gimple_call_arg (stmt, 2);
13540   if (!validate_arg (size, INTEGER_TYPE))
13541     return NULL_TREE;
13542   fmt = gimple_call_arg (stmt, 3);
13543   if (!validate_arg (fmt, POINTER_TYPE))
13544     return NULL_TREE;
13545
13546   if (! host_integerp (size, 1))
13547     return NULL_TREE;
13548
13549   len = NULL_TREE;
13550
13551   if (!init_target_chars ())
13552     return NULL_TREE;
13553
13554   /* Check whether the format is a literal string constant.  */
13555   fmt_str = c_getstr (fmt);
13556   if (fmt_str != NULL)
13557     {
13558       /* If the format doesn't contain % args or %%, we know the size.  */
13559       if (strchr (fmt_str, target_percent) == 0)
13560         {
13561           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
13562             len = build_int_cstu (size_type_node, strlen (fmt_str));
13563         }
13564       /* If the format is "%s" and first ... argument is a string literal,
13565          we know the size too.  */
13566       else if (fcode == BUILT_IN_SPRINTF_CHK
13567                && strcmp (fmt_str, target_percent_s) == 0)
13568         {
13569           tree arg;
13570
13571           if (nargs == 5)
13572             {
13573               arg = gimple_call_arg (stmt, 4);
13574               if (validate_arg (arg, POINTER_TYPE))
13575                 {
13576                   len = c_strlen (arg, 1);
13577                   if (! len || ! host_integerp (len, 1))
13578                     len = NULL_TREE;
13579                 }
13580             }
13581         }
13582     }
13583
13584   if (! integer_all_onesp (size))
13585     {
13586       if (! len || ! tree_int_cst_lt (len, size))
13587         return NULL_TREE;
13588     }
13589
13590   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13591      or if format doesn't contain % chars or is "%s".  */
13592   if (! integer_zerop (flag))
13593     {
13594       if (fmt_str == NULL)
13595         return NULL_TREE;
13596       if (strchr (fmt_str, target_percent) != NULL
13597           && strcmp (fmt_str, target_percent_s))
13598         return NULL_TREE;
13599     }
13600
13601   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
13602   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
13603                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
13604   if (!fn)
13605     return NULL_TREE;
13606
13607   return gimple_rewrite_call_expr (stmt, 4, fn, 2, dest, fmt);
13608 }
13609
13610 /* Fold a call STMT to {,v}snprintf.  Return NULL_TREE if
13611    a normal call should be emitted rather than expanding the function
13612    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
13613    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
13614    passed as second argument.  */
13615
13616 tree
13617 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
13618                                   enum built_in_function fcode)
13619 {
13620   tree dest, size, len, fn, fmt, flag;
13621   const char *fmt_str;
13622
13623   /* Verify the required arguments in the original call.  */
13624   if (gimple_call_num_args (stmt) < 5)
13625     return NULL_TREE;
13626   dest = gimple_call_arg (stmt, 0);
13627   if (!validate_arg (dest, POINTER_TYPE))
13628     return NULL_TREE;
13629   len = gimple_call_arg (stmt, 1);
13630   if (!validate_arg (len, INTEGER_TYPE))
13631     return NULL_TREE;
13632   flag = gimple_call_arg (stmt, 2);
13633   if (!validate_arg (flag, INTEGER_TYPE))
13634     return NULL_TREE;
13635   size = gimple_call_arg (stmt, 3);
13636   if (!validate_arg (size, INTEGER_TYPE))
13637     return NULL_TREE;
13638   fmt = gimple_call_arg (stmt, 4);
13639   if (!validate_arg (fmt, POINTER_TYPE))
13640     return NULL_TREE;
13641
13642   if (! host_integerp (size, 1))
13643     return NULL_TREE;
13644
13645   if (! integer_all_onesp (size))
13646     {
13647       if (! host_integerp (len, 1))
13648         {
13649           /* If LEN is not constant, try MAXLEN too.
13650              For MAXLEN only allow optimizing into non-_ocs function
13651              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
13652           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
13653             return NULL_TREE;
13654         }
13655       else
13656         maxlen = len;
13657
13658       if (tree_int_cst_lt (size, maxlen))
13659         return NULL_TREE;
13660     }
13661
13662   if (!init_target_chars ())
13663     return NULL_TREE;
13664
13665   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13666      or if format doesn't contain % chars or is "%s".  */
13667   if (! integer_zerop (flag))
13668     {
13669       fmt_str = c_getstr (fmt);
13670       if (fmt_str == NULL)
13671         return NULL_TREE;
13672       if (strchr (fmt_str, target_percent) != NULL
13673           && strcmp (fmt_str, target_percent_s))
13674         return NULL_TREE;
13675     }
13676
13677   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13678      available.  */
13679   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
13680                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
13681   if (!fn)
13682     return NULL_TREE;
13683
13684   return gimple_rewrite_call_expr (stmt, 5, fn, 3, dest, len, fmt);
13685 }
13686
13687 /* Builtins with folding operations that operate on "..." arguments
13688    need special handling; we need to store the arguments in a convenient
13689    data structure before attempting any folding.  Fortunately there are
13690    only a few builtins that fall into this category.  FNDECL is the
13691    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13692    result of the function call is ignored.  */
13693
13694 static tree
13695 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
13696                              bool ignore ATTRIBUTE_UNUSED)
13697 {
13698   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13699   tree ret = NULL_TREE;
13700
13701   switch (fcode)
13702     {
13703     case BUILT_IN_SPRINTF_CHK:
13704     case BUILT_IN_VSPRINTF_CHK:
13705       ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
13706       break;
13707
13708     case BUILT_IN_SNPRINTF_CHK:
13709     case BUILT_IN_VSNPRINTF_CHK:
13710       ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
13711
13712     default:
13713       break;
13714     }
13715   if (ret)
13716     {
13717       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
13718       TREE_NO_WARNING (ret) = 1;
13719       return ret;
13720     }
13721   return NULL_TREE;
13722 }
13723
13724 /* A wrapper function for builtin folding that prevents warnings for
13725    "statement without effect" and the like, caused by removing the
13726    call node earlier than the warning is generated.  */
13727
13728 tree
13729 fold_call_stmt (gimple stmt, bool ignore)
13730 {
13731   tree ret = NULL_TREE;
13732   tree fndecl = gimple_call_fndecl (stmt);
13733   location_t loc = gimple_location (stmt);
13734   if (fndecl
13735       && TREE_CODE (fndecl) == FUNCTION_DECL
13736       && DECL_BUILT_IN (fndecl)
13737       && !gimple_call_va_arg_pack_p (stmt))
13738     {
13739       int nargs = gimple_call_num_args (stmt);
13740
13741       if (avoid_folding_inline_builtin (fndecl))
13742         return NULL_TREE;
13743       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
13744         {
13745           return targetm.fold_builtin (fndecl, nargs,
13746                                        (nargs > 0
13747                                         ? gimple_call_arg_ptr (stmt, 0)
13748                                         : &error_mark_node), ignore);
13749         }
13750       else
13751         {
13752           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
13753             {
13754               tree args[MAX_ARGS_TO_FOLD_BUILTIN];
13755               int i;
13756               for (i = 0; i < nargs; i++)
13757                 args[i] = gimple_call_arg (stmt, i);
13758               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
13759             }
13760           if (!ret)
13761             ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
13762           if (ret)
13763             {
13764               /* Propagate location information from original call to
13765                  expansion of builtin.  Otherwise things like
13766                  maybe_emit_chk_warning, that operate on the expansion
13767                  of a builtin, will use the wrong location information.  */
13768               if (gimple_has_location (stmt))
13769                 {
13770                   tree realret = ret;
13771                   if (TREE_CODE (ret) == NOP_EXPR)
13772                     realret = TREE_OPERAND (ret, 0);
13773                   if (CAN_HAVE_LOCATION_P (realret)
13774                       && !EXPR_HAS_LOCATION (realret))
13775                     SET_EXPR_LOCATION (realret, loc);
13776                   return realret;
13777                 }
13778               return ret;
13779             }
13780         }
13781     }
13782   return NULL_TREE;
13783 }
13784
13785 /* Look up the function in built_in_decls that corresponds to DECL
13786    and set ASMSPEC as its user assembler name.  DECL must be a
13787    function decl that declares a builtin.  */
13788
13789 void
13790 set_builtin_user_assembler_name (tree decl, const char *asmspec)
13791 {
13792   tree builtin;
13793   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
13794               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
13795               && asmspec != 0);
13796
13797   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
13798   set_user_assembler_name (builtin, asmspec);
13799   switch (DECL_FUNCTION_CODE (decl))
13800     {
13801     case BUILT_IN_MEMCPY:
13802       init_block_move_fn (asmspec);
13803       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
13804       break;
13805     case BUILT_IN_MEMSET:
13806       init_block_clear_fn (asmspec);
13807       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
13808       break;
13809     case BUILT_IN_MEMMOVE:
13810       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
13811       break;
13812     case BUILT_IN_MEMCMP:
13813       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
13814       break;
13815     case BUILT_IN_ABORT:
13816       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
13817       break;
13818     case BUILT_IN_FFS:
13819       if (INT_TYPE_SIZE < BITS_PER_WORD)
13820         {
13821           set_user_assembler_libfunc ("ffs", asmspec);
13822           set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
13823                                                        MODE_INT, 0), "ffs");
13824         }
13825       break;
13826     default:
13827       break;
13828     }
13829 }
13830
13831 /* Return true if DECL is a builtin that expands to a constant or similarly
13832    simple code.  */
13833 bool
13834 is_simple_builtin (tree decl)
13835 {
13836   if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13837     switch (DECL_FUNCTION_CODE (decl))
13838       {
13839         /* Builtins that expand to constants.  */
13840       case BUILT_IN_CONSTANT_P:
13841       case BUILT_IN_EXPECT:
13842       case BUILT_IN_OBJECT_SIZE:
13843       case BUILT_IN_UNREACHABLE:
13844         /* Simple register moves or loads from stack.  */
13845       case BUILT_IN_RETURN_ADDRESS:
13846       case BUILT_IN_EXTRACT_RETURN_ADDR:
13847       case BUILT_IN_FROB_RETURN_ADDR:
13848       case BUILT_IN_RETURN:
13849       case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
13850       case BUILT_IN_FRAME_ADDRESS:
13851       case BUILT_IN_VA_END:
13852       case BUILT_IN_STACK_SAVE:
13853       case BUILT_IN_STACK_RESTORE:
13854         /* Exception state returns or moves registers around.  */
13855       case BUILT_IN_EH_FILTER:
13856       case BUILT_IN_EH_POINTER:
13857       case BUILT_IN_EH_COPY_VALUES:
13858         return true;
13859
13860       default:
13861         return false;
13862       }
13863
13864   return false;
13865 }
13866
13867 /* Return true if DECL is a builtin that is not expensive, i.e., they are
13868    most probably expanded inline into reasonably simple code.  This is a
13869    superset of is_simple_builtin.  */
13870 bool
13871 is_inexpensive_builtin (tree decl)
13872 {
13873   if (!decl)
13874     return false;
13875   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
13876     return true;
13877   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13878     switch (DECL_FUNCTION_CODE (decl))
13879       {
13880       case BUILT_IN_ABS:
13881       case BUILT_IN_ALLOCA:
13882       case BUILT_IN_BSWAP32:
13883       case BUILT_IN_BSWAP64:
13884       case BUILT_IN_CLZ:
13885       case BUILT_IN_CLZIMAX:
13886       case BUILT_IN_CLZL:
13887       case BUILT_IN_CLZLL:
13888       case BUILT_IN_CTZ:
13889       case BUILT_IN_CTZIMAX:
13890       case BUILT_IN_CTZL:
13891       case BUILT_IN_CTZLL:
13892       case BUILT_IN_FFS:
13893       case BUILT_IN_FFSIMAX:
13894       case BUILT_IN_FFSL:
13895       case BUILT_IN_FFSLL:
13896       case BUILT_IN_IMAXABS:
13897       case BUILT_IN_FINITE:
13898       case BUILT_IN_FINITEF:
13899       case BUILT_IN_FINITEL:
13900       case BUILT_IN_FINITED32:
13901       case BUILT_IN_FINITED64:
13902       case BUILT_IN_FINITED128:
13903       case BUILT_IN_FPCLASSIFY:
13904       case BUILT_IN_ISFINITE:
13905       case BUILT_IN_ISINF_SIGN:
13906       case BUILT_IN_ISINF:
13907       case BUILT_IN_ISINFF:
13908       case BUILT_IN_ISINFL:
13909       case BUILT_IN_ISINFD32:
13910       case BUILT_IN_ISINFD64:
13911       case BUILT_IN_ISINFD128:
13912       case BUILT_IN_ISNAN:
13913       case BUILT_IN_ISNANF:
13914       case BUILT_IN_ISNANL:
13915       case BUILT_IN_ISNAND32:
13916       case BUILT_IN_ISNAND64:
13917       case BUILT_IN_ISNAND128:
13918       case BUILT_IN_ISNORMAL:
13919       case BUILT_IN_ISGREATER:
13920       case BUILT_IN_ISGREATEREQUAL:
13921       case BUILT_IN_ISLESS:
13922       case BUILT_IN_ISLESSEQUAL:
13923       case BUILT_IN_ISLESSGREATER:
13924       case BUILT_IN_ISUNORDERED:
13925       case BUILT_IN_VA_ARG_PACK:
13926       case BUILT_IN_VA_ARG_PACK_LEN:
13927       case BUILT_IN_VA_COPY:
13928       case BUILT_IN_TRAP:
13929       case BUILT_IN_SAVEREGS:
13930       case BUILT_IN_POPCOUNTL:
13931       case BUILT_IN_POPCOUNTLL:
13932       case BUILT_IN_POPCOUNTIMAX:
13933       case BUILT_IN_POPCOUNT:
13934       case BUILT_IN_PARITYL:
13935       case BUILT_IN_PARITYLL:
13936       case BUILT_IN_PARITYIMAX:
13937       case BUILT_IN_PARITY:
13938       case BUILT_IN_LABS:
13939       case BUILT_IN_LLABS:
13940       case BUILT_IN_PREFETCH:
13941         return true;
13942
13943       default:
13944         return is_simple_builtin (decl);
13945       }
13946
13947   return false;
13948 }
13949