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, 2011
   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 "predict.h"
  44 #include "tm_p.h"
  45 #include "target.h"
  46 #include "langhooks.h"
  47 #include "basic-block.h"
  48 #include "tree-mudflap.h"
  49 #include "tree-flow.h"
  50 #include "value-prof.h"
  51 #include "diagnostic-core.h"
  52 #include "builtins.h"
  53
  54
  55 #ifndef PAD_VARARGS_DOWN
  56 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
  57 #endif
  58 static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));
  59
  60 struct target_builtins default_target_builtins;
  61 #if SWITCHABLE_TARGET
  62 struct target_builtins *this_target_builtins = &default_target_builtins;
  63 #endif
  64
  65 /* Define the names of the builtin function types and codes.  */
  66 const char *const built_in_class_names[4]
  67   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
  68
  69 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
  70 const char * built_in_names[(int) END_BUILTINS] =
  71 {
  72 #include "builtins.def"
  73 };
  74 #undef DEF_BUILTIN
  75
  76 /* Setup an array of _DECL trees, make sure each element is
  77    initialized to NULL_TREE.  */
  78 tree built_in_decls[(int) END_BUILTINS];
  79 /* Declarations used when constructing the builtin implicitly in the compiler.
  80    It may be NULL_TREE when this is invalid (for instance runtime is not
  81    required to implement the function call in all cases).  */
  82 tree implicit_built_in_decls[(int) END_BUILTINS];
  83
  84 static const char *c_getstr (tree);
  85 static rtx c_readstr (const char *, enum machine_mode);
  86 static int target_char_cast (tree, char *);
  87 static rtx get_memory_rtx (tree, tree);
  88 static int apply_args_size (void);
  89 static int apply_result_size (void);
  90 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
  91 static rtx result_vector (int, rtx);
  92 #endif
  93 static void expand_builtin_update_setjmp_buf (rtx);
  94 static void expand_builtin_prefetch (tree);
  95 static rtx expand_builtin_apply_args (void);
  96 static rtx expand_builtin_apply_args_1 (void);
  97 static rtx expand_builtin_apply (rtx, rtx, rtx);
  98 static void expand_builtin_return (rtx);
  99 static enum type_class type_to_class (tree);
 100 static rtx expand_builtin_classify_type (tree);
 101 static void expand_errno_check (tree, rtx);
 102 static rtx expand_builtin_mathfn (tree, rtx, rtx);
 103 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
 104 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
 105 static rtx expand_builtin_mathfn_ternary (tree, rtx, rtx);
 106 static rtx expand_builtin_interclass_mathfn (tree, rtx);
 107 static rtx expand_builtin_sincos (tree);
 108 static rtx expand_builtin_cexpi (tree, rtx);
 109 static rtx expand_builtin_int_roundingfn (tree, rtx);
 110 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
 111 static rtx expand_builtin_next_arg (void);
 112 static rtx expand_builtin_va_start (tree);
 113 static rtx expand_builtin_va_end (tree);
 114 static rtx expand_builtin_va_copy (tree);
 115 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
 116 static rtx expand_builtin_strcmp (tree, rtx);
 117 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
 118 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 119 static rtx expand_builtin_memcpy (tree, rtx);
 120 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
 121 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
 122                                         enum machine_mode, int);
 123 static rtx expand_builtin_strcpy (tree, rtx);
 124 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
 125 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
 126 static rtx expand_builtin_strncpy (tree, rtx);
 127 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
 128 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
 129 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
 130 static rtx expand_builtin_bzero (tree);
 131 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
 132 static rtx expand_builtin_alloca (tree, bool);
 133 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
 134 static rtx expand_builtin_frame_address (tree, tree);
 135 static tree stabilize_va_list_loc (location_t, tree, int);
 136 static rtx expand_builtin_expect (tree, rtx);
 137 static tree fold_builtin_constant_p (tree);
 138 static tree fold_builtin_expect (location_t, tree, tree);
 139 static tree fold_builtin_classify_type (tree);
 140 static tree fold_builtin_strlen (location_t, tree, tree);
 141 static tree fold_builtin_inf (location_t, tree, int);
 142 static tree fold_builtin_nan (tree, tree, int);
 143 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
 144 static bool validate_arg (const_tree, enum tree_code code);
 145 static bool integer_valued_real_p (tree);
 146 static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
 147 static bool readonly_data_expr (tree);
 148 static rtx expand_builtin_fabs (tree, rtx, rtx);
 149 static rtx expand_builtin_signbit (tree, rtx);
 150 static tree fold_builtin_sqrt (location_t, tree, tree);
 151 static tree fold_builtin_cbrt (location_t, tree, tree);
 152 static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
 153 static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
 154 static tree fold_builtin_cos (location_t, tree, tree, tree);
 155 static tree fold_builtin_cosh (location_t, tree, tree, tree);
 156 static tree fold_builtin_tan (tree, tree);
 157 static tree fold_builtin_trunc (location_t, tree, tree);
 158 static tree fold_builtin_floor (location_t, tree, tree);
 159 static tree fold_builtin_ceil (location_t, tree, tree);
 160 static tree fold_builtin_round (location_t, tree, tree);
 161 static tree fold_builtin_int_roundingfn (location_t, tree, tree);
 162 static tree fold_builtin_bitop (tree, tree);
 163 static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
 164 static tree fold_builtin_strchr (location_t, tree, tree, tree);
 165 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
 166 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
 167 static tree fold_builtin_strcmp (location_t, tree, tree);
 168 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
 169 static tree fold_builtin_signbit (location_t, tree, tree);
 170 static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
 171 static tree fold_builtin_isascii (location_t, tree);
 172 static tree fold_builtin_toascii (location_t, tree);
 173 static tree fold_builtin_isdigit (location_t, tree);
 174 static tree fold_builtin_fabs (location_t, tree, tree);
 175 static tree fold_builtin_abs (location_t, tree, tree);
 176 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
 177                                         enum tree_code);
 178 static tree fold_builtin_n (location_t, tree, tree *, int, bool);
 179 static tree fold_builtin_0 (location_t, tree, bool);
 180 static tree fold_builtin_1 (location_t, tree, tree, bool);
 181 static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
 182 static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
 183 static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
 184 static tree fold_builtin_varargs (location_t, tree, tree, bool);
 185
 186 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
 187 static tree fold_builtin_strstr (location_t, tree, tree, tree);
 188 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
 189 static tree fold_builtin_strcat (location_t, tree, tree);
 190 static tree fold_builtin_strncat (location_t, tree, tree, tree);
 191 static tree fold_builtin_strspn (location_t, tree, tree);
 192 static tree fold_builtin_strcspn (location_t, tree, tree);
 193 static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
 194 static tree fold_builtin_snprintf (location_t, tree, tree, tree, tree, int);
 195
 196 static rtx expand_builtin_object_size (tree);
 197 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
 198                                       enum built_in_function);
 199 static void maybe_emit_chk_warning (tree, enum built_in_function);
 200 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 201 static void maybe_emit_free_warning (tree);
 202 static tree fold_builtin_object_size (tree, tree);
 203 static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
 204 static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
 205 static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
 206 static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
 207 static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
 208                                   enum built_in_function);
 209 static bool init_target_chars (void);
 210
 211 static unsigned HOST_WIDE_INT target_newline;
 212 static unsigned HOST_WIDE_INT target_percent;
 213 static unsigned HOST_WIDE_INT target_c;
 214 static unsigned HOST_WIDE_INT target_s;
 215 static char target_percent_c[3];
 216 static char target_percent_s[3];
 217 static char target_percent_s_newline[4];
 218 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
 219                           const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
 220 static tree do_mpfr_arg2 (tree, tree, tree,
 221                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 222 static tree do_mpfr_arg3 (tree, tree, tree, tree,
 223                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 224 static tree do_mpfr_sincos (tree, tree, tree);
 225 static tree do_mpfr_bessel_n (tree, tree, tree,
 226                               int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
 227                               const REAL_VALUE_TYPE *, bool);
 228 static tree do_mpfr_remquo (tree, tree, tree);
 229 static tree do_mpfr_lgamma_r (tree, tree, tree);
 230
 231 /* Return true if NAME starts with __builtin_ or __sync_.  */
 232
 233 bool
 234 is_builtin_name (const char *name)
 235 {
 236   if (strncmp (name, "__builtin_", 10) == 0)
 237     return true;
 238   if (strncmp (name, "__sync_", 7) == 0)
 239     return true;
 240   return false;
 241 }
 242
 243
 244 /* Return true if DECL is a function symbol representing a built-in.  */
 245
 246 bool
 247 is_builtin_fn (tree decl)
 248 {
 249   return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
 250 }
 251
 252
 253 /* Return true if NODE should be considered for inline expansion regardless
 254    of the optimization level.  This means whenever a function is invoked with
 255    its "internal" name, which normally contains the prefix "__builtin".  */
 256
 257 static bool
 258 called_as_built_in (tree node)
 259 {
 260   /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
 261      we want the name used to call the function, not the name it
 262      will have. */
 263   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 264   return is_builtin_name (name);
 265 }
 266
 267 /* Return the alignment in bits of EXP, an object.
 268    Don't return more than MAX_ALIGN no matter what.  */
 269
 270 unsigned int
 271 get_object_alignment (tree exp, unsigned int max_align)
 272 {
 273   HOST_WIDE_INT bitsize, bitpos;
 274   tree offset;
 275   enum machine_mode mode;
 276   int unsignedp, volatilep;
 277   unsigned int align, inner;
 278
 279   /* Get the innermost object and the constant (bitpos) and possibly
 280      variable (offset) offset of the access.  */
 281   exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
 282                              &mode, &unsignedp, &volatilep, true);
 283
 284   /* Extract alignment information from the innermost object and
 285      possibly adjust bitpos and offset.  */
 286   if (TREE_CODE (exp) == CONST_DECL)
 287     exp = DECL_INITIAL (exp);
 288   if (DECL_P (exp)
 289       && TREE_CODE (exp) != LABEL_DECL)
 290     align = DECL_ALIGN (exp);
 291   else if (CONSTANT_CLASS_P (exp))
 292     {
 293       align = TYPE_ALIGN (TREE_TYPE (exp));
 294 #ifdef CONSTANT_ALIGNMENT
 295       align = (unsigned)CONSTANT_ALIGNMENT (exp, align);
 296 #endif
 297     }
 298   else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
 299     align = TYPE_ALIGN (TREE_TYPE (exp));
 300   else if (TREE_CODE (exp) == INDIRECT_REF)
 301     align = TYPE_ALIGN (TREE_TYPE (exp));
 302   else if (TREE_CODE (exp) == MEM_REF)
 303     {
 304       tree addr = TREE_OPERAND (exp, 0);
 305       struct ptr_info_def *pi;
 306       if (TREE_CODE (addr) == BIT_AND_EXPR
 307           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 308         {
 309           align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 310                     & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 311           align *= BITS_PER_UNIT;
 312           addr = TREE_OPERAND (addr, 0);
 313         }
 314       else
 315         align = BITS_PER_UNIT;
 316       if (TREE_CODE (addr) == SSA_NAME
 317           && (pi = SSA_NAME_PTR_INFO (addr)))
 318         {
 319           bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
 320           align = MAX (pi->align * BITS_PER_UNIT, align);
 321         }
 322       else if (TREE_CODE (addr) == ADDR_EXPR)
 323         align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
 324                                                   max_align));
 325       bitpos += mem_ref_offset (exp).low * BITS_PER_UNIT;
 326     }
 327   else if (TREE_CODE (exp) == TARGET_MEM_REF)
 328     {
 329       struct ptr_info_def *pi;
 330       tree addr = TMR_BASE (exp);
 331       if (TREE_CODE (addr) == BIT_AND_EXPR
 332           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 333         {
 334           align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 335                    & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 336           align *= BITS_PER_UNIT;
 337           addr = TREE_OPERAND (addr, 0);
 338         }
 339       else
 340         align = BITS_PER_UNIT;
 341       if (TREE_CODE (addr) == SSA_NAME
 342           && (pi = SSA_NAME_PTR_INFO (addr)))
 343         {
 344           bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
 345           align = MAX (pi->align * BITS_PER_UNIT, align);
 346         }
 347       else if (TREE_CODE (addr) == ADDR_EXPR)
 348         align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
 349                                                   max_align));
 350       if (TMR_OFFSET (exp))
 351         bitpos += TREE_INT_CST_LOW (TMR_OFFSET (exp)) * BITS_PER_UNIT;
 352       if (TMR_INDEX (exp) && TMR_STEP (exp))
 353         {
 354           unsigned HOST_WIDE_INT step = TREE_INT_CST_LOW (TMR_STEP (exp));
 355           align = MIN (align, (step & -step) * BITS_PER_UNIT);
 356         }
 357       else if (TMR_INDEX (exp))
 358         align = BITS_PER_UNIT;
 359       if (TMR_INDEX2 (exp))
 360         align = BITS_PER_UNIT;
 361     }
 362   else
 363     align = BITS_PER_UNIT;
 364
 365   /* If there is a non-constant offset part extract the maximum
 366      alignment that can prevail.  */
 367   inner = max_align;
 368   while (offset)
 369     {
 370       tree next_offset;
 371
 372       if (TREE_CODE (offset) == PLUS_EXPR)
 373         {
 374           next_offset = TREE_OPERAND (offset, 0);
 375           offset = TREE_OPERAND (offset, 1);
 376         }
 377       else
 378         next_offset = NULL;
 379       if (host_integerp (offset, 1))
 380         {
 381           /* Any overflow in calculating offset_bits won't change
 382              the alignment.  */
 383           unsigned offset_bits
 384             = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
 385
 386           if (offset_bits)
 387             inner = MIN (inner, (offset_bits & -offset_bits));
 388         }
 389       else if (TREE_CODE (offset) == MULT_EXPR
 390                && host_integerp (TREE_OPERAND (offset, 1), 1))
 391         {
 392           /* Any overflow in calculating offset_factor won't change
 393              the alignment.  */
 394           unsigned offset_factor
 395             = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
 396                * BITS_PER_UNIT);
 397
 398           if (offset_factor)
 399             inner = MIN (inner, (offset_factor & -offset_factor));
 400         }
 401       else
 402         {
 403           inner = MIN (inner, BITS_PER_UNIT);
 404           break;
 405         }
 406       offset = next_offset;
 407     }
 408
 409   /* Alignment is innermost object alignment adjusted by the constant
 410      and non-constant offset parts.  */
 411   align = MIN (align, inner);
 412   bitpos = bitpos & (align - 1);
 413
 414   /* align and bitpos now specify known low bits of the pointer.
 415      ptr & (align - 1) == bitpos.  */
 416
 417   if (bitpos != 0)
 418     align = (bitpos & -bitpos);
 419
 420   return MIN (align, max_align);
 421 }
 422
 423 /* Returns true iff we can trust that alignment information has been
 424    calculated properly.  */
 425
 426 bool
 427 can_trust_pointer_alignment (void)
 428 {
 429   /* We rely on TER to compute accurate alignment information.  */
 430   return (optimize && flag_tree_ter);
 431 }
 432
 433 /* Return the alignment in bits of EXP, a pointer valued expression.
 434    But don't return more than MAX_ALIGN no matter what.
 435    The alignment returned is, by default, the alignment of the thing that
 436    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 437
 438    Otherwise, look at the expression to see if we can do better, i.e., if the
 439    expression is actually pointing at an object whose alignment is tighter.  */
 440
 441 unsigned int
 442 get_pointer_alignment (tree exp, unsigned int max_align)
 443 {
 444   STRIP_NOPS (exp);
 445
 446   if (TREE_CODE (exp) == ADDR_EXPR)
 447     return get_object_alignment (TREE_OPERAND (exp, 0), max_align);
 448   else if (TREE_CODE (exp) == SSA_NAME
 449            && POINTER_TYPE_P (TREE_TYPE (exp)))
 450     {
 451       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);
 452       unsigned align;
 453       if (!pi)
 454         return BITS_PER_UNIT;
 455       if (pi->misalign != 0)
 456         align = (pi->misalign & -pi->misalign);
 457       else
 458         align = pi->align;
 459       return MIN (max_align, align * BITS_PER_UNIT);
 460     }
 461
 462   return POINTER_TYPE_P (TREE_TYPE (exp)) ? BITS_PER_UNIT : 0;
 463 }
 464
 465 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 466    way, because it could contain a zero byte in the middle.
 467    TREE_STRING_LENGTH is the size of the character array, not the string.
 468
 469    ONLY_VALUE should be nonzero if the result is not going to be emitted
 470    into the instruction stream and zero if it is going to be expanded.
 471    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 472    is returned, otherwise NULL, since
 473    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
 474    evaluate the side-effects.
 475
 476    The value returned is of type `ssizetype'.
 477
 478    Unfortunately, string_constant can't access the values of const char
 479    arrays with initializers, so neither can we do so here.  */
 480
 481 tree
 482 c_strlen (tree src, int only_value)
 483 {
 484   tree offset_node;
 485   HOST_WIDE_INT offset;
 486   int max;
 487   const char *ptr;
 488   location_t loc;
 489
 490   STRIP_NOPS (src);
 491   if (TREE_CODE (src) == COND_EXPR
 492       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 493     {
 494       tree len1, len2;
 495
 496       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
 497       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
 498       if (tree_int_cst_equal (len1, len2))
 499         return len1;
 500     }
 501
 502   if (TREE_CODE (src) == COMPOUND_EXPR
 503       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 504     return c_strlen (TREE_OPERAND (src, 1), only_value);
 505
 506   loc = EXPR_LOC_OR_HERE (src);
 507
 508   src = string_constant (src, &offset_node);
 509   if (src == 0)
 510     return NULL_TREE;
 511
 512   max = TREE_STRING_LENGTH (src) - 1;
 513   ptr = TREE_STRING_POINTER (src);
 514
 515   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 516     {
 517       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 518          compute the offset to the following null if we don't know where to
 519          start searching for it.  */
 520       int i;
 521
 522       for (i = 0; i < max; i++)
 523         if (ptr[i] == 0)
 524           return NULL_TREE;
 525
 526       /* We don't know the starting offset, but we do know that the string
 527          has no internal zero bytes.  We can assume that the offset falls
 528          within the bounds of the string; otherwise, the programmer deserves
 529          what he gets.  Subtract the offset from the length of the string,
 530          and return that.  This would perhaps not be valid if we were dealing
 531          with named arrays in addition to literal string constants.  */
 532
 533       return size_diffop_loc (loc, size_int (max), offset_node);
 534     }
 535
 536   /* We have a known offset into the string.  Start searching there for
 537      a null character if we can represent it as a single HOST_WIDE_INT.  */
 538   if (offset_node == 0)
 539     offset = 0;
 540   else if (! host_integerp (offset_node, 0))
 541     offset = -1;
 542   else
 543     offset = tree_low_cst (offset_node, 0);
 544
 545   /* If the offset is known to be out of bounds, warn, and call strlen at
 546      runtime.  */
 547   if (offset < 0 || offset > max)
 548     {
 549      /* Suppress multiple warnings for propagated constant strings.  */
 550       if (! TREE_NO_WARNING (src))
 551         {
 552           warning_at (loc, 0, "offset outside bounds of constant string");
 553           TREE_NO_WARNING (src) = 1;
 554         }
 555       return NULL_TREE;
 556     }
 557
 558   /* Use strlen to search for the first zero byte.  Since any strings
 559      constructed with build_string will have nulls appended, we win even
 560      if we get handed something like (char[4])"abcd".
 561
 562      Since OFFSET is our starting index into the string, no further
 563      calculation is needed.  */
 564   return ssize_int (strlen (ptr + offset));
 565 }
 566
 567 /* Return a char pointer for a C string if it is a string constant
 568    or sum of string constant and integer constant.  */
 569
 570 static const char *
 571 c_getstr (tree src)
 572 {
 573   tree offset_node;
 574
 575   src = string_constant (src, &offset_node);
 576   if (src == 0)
 577     return 0;
 578
 579   if (offset_node == 0)
 580     return TREE_STRING_POINTER (src);
 581   else if (!host_integerp (offset_node, 1)
 582            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
 583     return 0;
 584
 585   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
 586 }
 587
 588 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
 589    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 590
 591 static rtx
 592 c_readstr (const char *str, enum machine_mode mode)
 593 {
 594   HOST_WIDE_INT c[2];
 595   HOST_WIDE_INT ch;
 596   unsigned int i, j;
 597
 598   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
 599
 600   c[0] = 0;
 601   c[1] = 0;
 602   ch = 1;
 603   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 604     {
 605       j = i;
 606       if (WORDS_BIG_ENDIAN)
 607         j = GET_MODE_SIZE (mode) - i - 1;
 608       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 609           && GET_MODE_SIZE (mode) >= UNITS_PER_WORD)
 610         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 611       j *= BITS_PER_UNIT;
 612       gcc_assert (j < 2 * HOST_BITS_PER_WIDE_INT);
 613
 614       if (ch)
 615         ch = (unsigned char) str[i];
 616       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 617     }
 618   return immed_double_const (c[0], c[1], mode);
 619 }
 620
 621 /* Cast a target constant CST to target CHAR and if that value fits into
 622    host char type, return zero and put that value into variable pointed to by
 623    P.  */
 624
 625 static int
 626 target_char_cast (tree cst, char *p)
 627 {
 628   unsigned HOST_WIDE_INT val, hostval;
 629
 630   if (TREE_CODE (cst) != INTEGER_CST
 631       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 632     return 1;
 633
 634   val = TREE_INT_CST_LOW (cst);
 635   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 636     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 637
 638   hostval = val;
 639   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 640     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 641
 642   if (val != hostval)
 643     return 1;
 644
 645   *p = hostval;
 646   return 0;
 647 }
 648
 649 /* Similar to save_expr, but assumes that arbitrary code is not executed
 650    in between the multiple evaluations.  In particular, we assume that a
 651    non-addressable local variable will not be modified.  */
 652
 653 static tree
 654 builtin_save_expr (tree exp)
 655 {
 656   if (TREE_CODE (exp) == SSA_NAME
 657       || (TREE_ADDRESSABLE (exp) == 0
 658           && (TREE_CODE (exp) == PARM_DECL
 659               || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp)))))
 660     return exp;
 661
 662   return save_expr (exp);
 663 }
 664
 665 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 666    times to get the address of either a higher stack frame, or a return
 667    address located within it (depending on FNDECL_CODE).  */
 668
 669 static rtx
 670 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
 671 {
 672   int i;
 673
 674 #ifdef INITIAL_FRAME_ADDRESS_RTX
 675   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
 676 #else
 677   rtx tem;
 678
 679   /* For a zero count with __builtin_return_address, we don't care what
 680      frame address we return, because target-specific definitions will
 681      override us.  Therefore frame pointer elimination is OK, and using
 682      the soft frame pointer is OK.
 683
 684      For a nonzero count, or a zero count with __builtin_frame_address,
 685      we require a stable offset from the current frame pointer to the
 686      previous one, so we must use the hard frame pointer, and
 687      we must disable frame pointer elimination.  */
 688   if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
 689     tem = frame_pointer_rtx;
 690   else
 691     {
 692       tem = hard_frame_pointer_rtx;
 693
 694       /* Tell reload not to eliminate the frame pointer.  */
 695       crtl->accesses_prior_frames = 1;
 696     }
 697 #endif
 698
 699   /* Some machines need special handling before we can access
 700      arbitrary frames.  For example, on the SPARC, we must first flush
 701      all register windows to the stack.  */
 702 #ifdef SETUP_FRAME_ADDRESSES
 703   if (count > 0)
 704     SETUP_FRAME_ADDRESSES ();
 705 #endif
 706
 707   /* On the SPARC, the return address is not in the frame, it is in a
 708      register.  There is no way to access it off of the current frame
 709      pointer, but it can be accessed off the previous frame pointer by
 710      reading the value from the register window save area.  */
 711 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
 712   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
 713     count--;
 714 #endif
 715
 716   /* Scan back COUNT frames to the specified frame.  */
 717   for (i = 0; i < count; i++)
 718     {
 719       /* Assume the dynamic chain pointer is in the word that the
 720          frame address points to, unless otherwise specified.  */
 721 #ifdef DYNAMIC_CHAIN_ADDRESS
 722       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 723 #endif
 724       tem = memory_address (Pmode, tem);
 725       tem = gen_frame_mem (Pmode, tem);
 726       tem = copy_to_reg (tem);
 727     }
 728
 729   /* For __builtin_frame_address, return what we've got.  But, on
 730      the SPARC for example, we may have to add a bias.  */
 731   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 732 #ifdef FRAME_ADDR_RTX
 733     return FRAME_ADDR_RTX (tem);
 734 #else
 735     return tem;
 736 #endif
 737
 738   /* For __builtin_return_address, get the return address from that frame.  */
 739 #ifdef RETURN_ADDR_RTX
 740   tem = RETURN_ADDR_RTX (count, tem);
 741 #else
 742   tem = memory_address (Pmode,
 743                         plus_constant (tem, GET_MODE_SIZE (Pmode)));
 744   tem = gen_frame_mem (Pmode, tem);
 745 #endif
 746   return tem;
 747 }
 748
 749 /* Alias set used for setjmp buffer.  */
 750 static alias_set_type setjmp_alias_set = -1;
 751
 752 /* Construct the leading half of a __builtin_setjmp call.  Control will
 753    return to RECEIVER_LABEL.  This is also called directly by the SJLJ
 754    exception handling code.  */
 755
 756 void
 757 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 758 {
 759   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 760   rtx stack_save;
 761   rtx mem;
 762
 763   if (setjmp_alias_set == -1)
 764     setjmp_alias_set = new_alias_set ();
 765
 766   buf_addr = convert_memory_address (Pmode, buf_addr);
 767
 768   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 769
 770   /* We store the frame pointer and the address of receiver_label in
 771      the buffer and use the rest of it for the stack save area, which
 772      is machine-dependent.  */
 773
 774   mem = gen_rtx_MEM (Pmode, buf_addr);
 775   set_mem_alias_set (mem, setjmp_alias_set);
 776   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
 777
 778   mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
 779   set_mem_alias_set (mem, setjmp_alias_set);
 780
 781   emit_move_insn (validize_mem (mem),
 782                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 783
 784   stack_save = gen_rtx_MEM (sa_mode,
 785                             plus_constant (buf_addr,
 786                                            2 * GET_MODE_SIZE (Pmode)));
 787   set_mem_alias_set (stack_save, setjmp_alias_set);
 788   emit_stack_save (SAVE_NONLOCAL, &stack_save);
 789
 790   /* If there is further processing to do, do it.  */
 791 #ifdef HAVE_builtin_setjmp_setup
 792   if (HAVE_builtin_setjmp_setup)
 793     emit_insn (gen_builtin_setjmp_setup (buf_addr));
 794 #endif
 795
 796   /* Tell optimize_save_area_alloca that extra work is going to
 797      need to go on during alloca.  */
 798   cfun->calls_setjmp = 1;
 799
 800   /* We have a nonlocal label.   */
 801   cfun->has_nonlocal_label = 1;
 802 }
 803
 804 /* Construct the trailing part of a __builtin_setjmp call.  This is
 805    also called directly by the SJLJ exception handling code.  */
 806
 807 void
 808 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
 809 {
 810   rtx chain;
 811
 812   /* Clobber the FP when we get here, so we have to make sure it's
 813      marked as used by this function.  */
 814   emit_use (hard_frame_pointer_rtx);
 815
 816   /* Mark the static chain as clobbered here so life information
 817      doesn't get messed up for it.  */
 818   chain = targetm.calls.static_chain (current_function_decl, true);
 819   if (chain && REG_P (chain))
 820     emit_clobber (chain);
 821
 822   /* Now put in the code to restore the frame pointer, and argument
 823      pointer, if needed.  */
 824 #ifdef HAVE_nonlocal_goto
 825   if (! HAVE_nonlocal_goto)
 826 #endif
 827     {
 828       emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 829       /* This might change the hard frame pointer in ways that aren't
 830          apparent to early optimization passes, so force a clobber.  */
 831       emit_clobber (hard_frame_pointer_rtx);
 832     }
 833
 834 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
 835   if (fixed_regs[ARG_POINTER_REGNUM])
 836     {
 837 #ifdef ELIMINABLE_REGS
 838       size_t i;
 839       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 840
 841       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 842         if (elim_regs[i].from == ARG_POINTER_REGNUM
 843             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 844           break;
 845
 846       if (i == ARRAY_SIZE (elim_regs))
 847 #endif
 848         {
 849           /* Now restore our arg pointer from the address at which it
 850              was saved in our stack frame.  */
 851           emit_move_insn (crtl->args.internal_arg_pointer,
 852                           copy_to_reg (get_arg_pointer_save_area ()));
 853         }
 854     }
 855 #endif
 856
 857 #ifdef HAVE_builtin_setjmp_receiver
 858   if (HAVE_builtin_setjmp_receiver)
 859     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
 860   else
 861 #endif
 862 #ifdef HAVE_nonlocal_goto_receiver
 863     if (HAVE_nonlocal_goto_receiver)
 864       emit_insn (gen_nonlocal_goto_receiver ());
 865     else
 866 #endif
 867       { /* Nothing */ }
 868
 869   /* We must not allow the code we just generated to be reordered by
 870      scheduling.  Specifically, the update of the frame pointer must
 871      happen immediately, not later.  */
 872   emit_insn (gen_blockage ());
 873 }
 874
 875 /* __builtin_longjmp is passed a pointer to an array of five words (not
 876    all will be used on all machines).  It operates similarly to the C
 877    library function of the same name, but is more efficient.  Much of
 878    the code below is copied from the handling of non-local gotos.  */
 879
 880 static void
 881 expand_builtin_longjmp (rtx buf_addr, rtx value)
 882 {
 883   rtx fp, lab, stack, insn, last;
 884   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 885
 886   /* DRAP is needed for stack realign if longjmp is expanded to current
 887      function  */
 888   if (SUPPORTS_STACK_ALIGNMENT)
 889     crtl->need_drap = true;
 890
 891   if (setjmp_alias_set == -1)
 892     setjmp_alias_set = new_alias_set ();
 893
 894   buf_addr = convert_memory_address (Pmode, buf_addr);
 895
 896   buf_addr = force_reg (Pmode, buf_addr);
 897
 898   /* We require that the user must pass a second argument of 1, because
 899      that is what builtin_setjmp will return.  */
 900   gcc_assert (value == const1_rtx);
 901
 902   last = get_last_insn ();
 903 #ifdef HAVE_builtin_longjmp
 904   if (HAVE_builtin_longjmp)
 905     emit_insn (gen_builtin_longjmp (buf_addr));
 906   else
 907 #endif
 908     {
 909       fp = gen_rtx_MEM (Pmode, buf_addr);
 910       lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
 911                                                GET_MODE_SIZE (Pmode)));
 912
 913       stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
 914                                                    2 * GET_MODE_SIZE (Pmode)));
 915       set_mem_alias_set (fp, setjmp_alias_set);
 916       set_mem_alias_set (lab, setjmp_alias_set);
 917       set_mem_alias_set (stack, setjmp_alias_set);
 918
 919       /* Pick up FP, label, and SP from the block and jump.  This code is
 920          from expand_goto in stmt.c; see there for detailed comments.  */
 921 #ifdef HAVE_nonlocal_goto
 922       if (HAVE_nonlocal_goto)
 923         /* We have to pass a value to the nonlocal_goto pattern that will
 924            get copied into the static_chain pointer, but it does not matter
 925            what that value is, because builtin_setjmp does not use it.  */
 926         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
 927       else
 928 #endif
 929         {
 930           lab = copy_to_reg (lab);
 931
 932           emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 933           emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 934
 935           emit_move_insn (hard_frame_pointer_rtx, fp);
 936           emit_stack_restore (SAVE_NONLOCAL, stack);
 937
 938           emit_use (hard_frame_pointer_rtx);
 939           emit_use (stack_pointer_rtx);
 940           emit_indirect_jump (lab);
 941         }
 942     }
 943
 944   /* Search backwards and mark the jump insn as a non-local goto.
 945      Note that this precludes the use of __builtin_longjmp to a
 946      __builtin_setjmp target in the same function.  However, we've
 947      already cautioned the user that these functions are for
 948      internal exception handling use only.  */
 949   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 950     {
 951       gcc_assert (insn != last);
 952
 953       if (JUMP_P (insn))
 954         {
 955           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
 956           break;
 957         }
 958       else if (CALL_P (insn))
 959         break;
 960     }
 961 }
 962
 963 /* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
 964    and the address of the save area.  */
 965
 966 static rtx
 967 expand_builtin_nonlocal_goto (tree exp)
 968 {
 969   tree t_label, t_save_area;
 970   rtx r_label, r_save_area, r_fp, r_sp, insn;
 971
 972   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
 973     return NULL_RTX;
 974
 975   t_label = CALL_EXPR_ARG (exp, 0);
 976   t_save_area = CALL_EXPR_ARG (exp, 1);
 977
 978   r_label = expand_normal (t_label);
 979   r_label = convert_memory_address (Pmode, r_label);
 980   r_save_area = expand_normal (t_save_area);
 981   r_save_area = convert_memory_address (Pmode, r_save_area);
 982   /* Copy the address of the save location to a register just in case it was based
 983     on the frame pointer.   */
 984   r_save_area = copy_to_reg (r_save_area);
 985   r_fp = gen_rtx_MEM (Pmode, r_save_area);
 986   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
 987                       plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
 988
 989   crtl->has_nonlocal_goto = 1;
 990
 991 #ifdef HAVE_nonlocal_goto
 992   /* ??? We no longer need to pass the static chain value, afaik.  */
 993   if (HAVE_nonlocal_goto)
 994     emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
 995   else
 996 #endif
 997     {
 998       r_label = copy_to_reg (r_label);
 999
1000       emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1001       emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1002
1003       /* Restore frame pointer for containing function.
1004          This sets the actual hard register used for the frame pointer
1005          to the location of the function's incoming static chain info.
1006          The non-local goto handler will then adjust it to contain the
1007          proper value and reload the argument pointer, if needed.  */
1008       emit_move_insn (hard_frame_pointer_rtx, r_fp);
1009       emit_stack_restore (SAVE_NONLOCAL, r_sp);
1010
1011       /* USE of hard_frame_pointer_rtx added for consistency;
1012          not clear if really needed.  */
1013       emit_use (hard_frame_pointer_rtx);
1014       emit_use (stack_pointer_rtx);
1015
1016       /* If the architecture is using a GP register, we must
1017          conservatively assume that the target function makes use of it.
1018          The prologue of functions with nonlocal gotos must therefore
1019          initialize the GP register to the appropriate value, and we
1020          must then make sure that this value is live at the point
1021          of the jump.  (Note that this doesn't necessarily apply
1022          to targets with a nonlocal_goto pattern; they are free
1023          to implement it in their own way.  Note also that this is
1024          a no-op if the GP register is a global invariant.)  */
1025       if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
1026           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
1027         emit_use (pic_offset_table_rtx);
1028
1029       emit_indirect_jump (r_label);
1030     }
1031
1032   /* Search backwards to the jump insn and mark it as a
1033      non-local goto.  */
1034   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1035     {
1036       if (JUMP_P (insn))
1037         {
1038           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1039           break;
1040         }
1041       else if (CALL_P (insn))
1042         break;
1043     }
1044
1045   return const0_rtx;
1046 }
1047
1048 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1049    (not all will be used on all machines) that was passed to __builtin_setjmp.
1050    It updates the stack pointer in that block to correspond to the current
1051    stack pointer.  */
1052
1053 static void
1054 expand_builtin_update_setjmp_buf (rtx buf_addr)
1055 {
1056   enum machine_mode sa_mode = Pmode;
1057   rtx stack_save;
1058
1059
1060 #ifdef HAVE_save_stack_nonlocal
1061   if (HAVE_save_stack_nonlocal)
1062     sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
1063 #endif
1064 #ifdef STACK_SAVEAREA_MODE
1065   sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1066 #endif
1067
1068   stack_save
1069     = gen_rtx_MEM (sa_mode,
1070                    memory_address
1071                    (sa_mode,
1072                     plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1073
1074 #ifdef HAVE_setjmp
1075   if (HAVE_setjmp)
1076     emit_insn (gen_setjmp ());
1077 #endif
1078
1079   emit_stack_save (SAVE_NONLOCAL, &stack_save);
1080 }
1081
1082 /* Expand a call to __builtin_prefetch.  For a target that does not support
1083    data prefetch, evaluate the memory address argument in case it has side
1084    effects.  */
1085
1086 static void
1087 expand_builtin_prefetch (tree exp)
1088 {
1089   tree arg0, arg1, arg2;
1090   int nargs;
1091   rtx op0, op1, op2;
1092
1093   if (!validate_arglist (exp, POINTER_TYPE, 0))
1094     return;
1095
1096   arg0 = CALL_EXPR_ARG (exp, 0);
1097
1098   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1099      zero (read) and argument 2 (locality) defaults to 3 (high degree of
1100      locality).  */
1101   nargs = call_expr_nargs (exp);
1102   if (nargs > 1)
1103     arg1 = CALL_EXPR_ARG (exp, 1);
1104   else
1105     arg1 = integer_zero_node;
1106   if (nargs > 2)
1107     arg2 = CALL_EXPR_ARG (exp, 2);
1108   else
1109     arg2 = integer_three_node;
1110
1111   /* Argument 0 is an address.  */
1112   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1113
1114   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
1115   if (TREE_CODE (arg1) != INTEGER_CST)
1116     {
1117       error ("second argument to %<__builtin_prefetch%> must be a constant");
1118       arg1 = integer_zero_node;
1119     }
1120   op1 = expand_normal (arg1);
1121   /* Argument 1 must be either zero or one.  */
1122   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1123     {
1124       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1125                " using zero");
1126       op1 = const0_rtx;
1127     }
1128
1129   /* Argument 2 (locality) must be a compile-time constant int.  */
1130   if (TREE_CODE (arg2) != INTEGER_CST)
1131     {
1132       error ("third argument to %<__builtin_prefetch%> must be a constant");
1133       arg2 = integer_zero_node;
1134     }
1135   op2 = expand_normal (arg2);
1136   /* Argument 2 must be 0, 1, 2, or 3.  */
1137   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1138     {
1139       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1140       op2 = const0_rtx;
1141     }
1142
1143 #ifdef HAVE_prefetch
1144   if (HAVE_prefetch)
1145     {
1146       struct expand_operand ops[3];
1147
1148       create_address_operand (&ops[0], op0);
1149       create_integer_operand (&ops[1], INTVAL (op1));
1150       create_integer_operand (&ops[2], INTVAL (op2));
1151       if (maybe_expand_insn (CODE_FOR_prefetch, 3, ops))
1152         return;
1153     }
1154 #endif
1155
1156   /* Don't do anything with direct references to volatile memory, but
1157      generate code to handle other side effects.  */
1158   if (!MEM_P (op0) && side_effects_p (op0))
1159     emit_insn (op0);
1160 }
1161
1162 /* Get a MEM rtx for expression EXP which is the address of an operand
1163    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1164    the maximum length of the block of memory that might be accessed or
1165    NULL if unknown.  */
1166
1167 static rtx
1168 get_memory_rtx (tree exp, tree len)
1169 {
1170   tree orig_exp = exp;
1171   rtx addr, mem;
1172   HOST_WIDE_INT off;
1173
1174   /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1175      from its expression, for expr->a.b only <variable>.a.b is recorded.  */
1176   if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1177     exp = TREE_OPERAND (exp, 0);
1178
1179   addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1180   mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1181
1182   /* Get an expression we can use to find the attributes to assign to MEM.
1183      If it is an ADDR_EXPR, use the operand.  Otherwise, dereference it if
1184      we can.  First remove any nops.  */
1185   while (CONVERT_EXPR_P (exp)
1186          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1187     exp = TREE_OPERAND (exp, 0);
1188
1189   off = 0;
1190   if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1191       && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1192       && host_integerp (TREE_OPERAND (exp, 1), 0)
1193       && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1194     exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1195   else if (TREE_CODE (exp) == ADDR_EXPR)
1196     exp = TREE_OPERAND (exp, 0);
1197   else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1198     exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1199   else
1200     exp = NULL;
1201
1202   /* Honor attributes derived from exp, except for the alias set
1203      (as builtin stringops may alias with anything) and the size
1204      (as stringops may access multiple array elements).  */
1205   if (exp)
1206     {
1207       set_mem_attributes (mem, exp, 0);
1208
1209       if (off)
1210         mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1211
1212       /* Allow the string and memory builtins to overflow from one
1213          field into another, see http://gcc.gnu.org/PR23561.
1214          Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1215          memory accessed by the string or memory builtin will fit
1216          within the field.  */
1217       if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1218         {
1219           tree mem_expr = MEM_EXPR (mem);
1220           HOST_WIDE_INT offset = -1, length = -1;
1221           tree inner = exp;
1222
1223           while (TREE_CODE (inner) == ARRAY_REF
1224                  || CONVERT_EXPR_P (inner)
1225                  || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1226                  || TREE_CODE (inner) == SAVE_EXPR)
1227             inner = TREE_OPERAND (inner, 0);
1228
1229           gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1230
1231           if (MEM_OFFSET (mem)
1232               && CONST_INT_P (MEM_OFFSET (mem)))
1233             offset = INTVAL (MEM_OFFSET (mem));
1234
1235           if (offset >= 0 && len && host_integerp (len, 0))
1236             length = tree_low_cst (len, 0);
1237
1238           while (TREE_CODE (inner) == COMPONENT_REF)
1239             {
1240               tree field = TREE_OPERAND (inner, 1);
1241               gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1242               gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1243
1244               /* Bitfields are generally not byte-addressable.  */
1245               gcc_assert (!DECL_BIT_FIELD (field)
1246                           || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1247                                % BITS_PER_UNIT) == 0
1248                               && host_integerp (DECL_SIZE (field), 0)
1249                               && (TREE_INT_CST_LOW (DECL_SIZE (field))
1250                                   % BITS_PER_UNIT) == 0));
1251
1252               /* If we can prove that the memory starting at XEXP (mem, 0) and
1253                  ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1254                  can keep the COMPONENT_REF in MEM_EXPR.  But be careful with
1255                  fields without DECL_SIZE_UNIT like flexible array members.  */
1256               if (length >= 0
1257                   && DECL_SIZE_UNIT (field)
1258                   && host_integerp (DECL_SIZE_UNIT (field), 0))
1259                 {
1260                   HOST_WIDE_INT size
1261                     = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1262                   if (offset <= size
1263                       && length <= size
1264                       && offset + length <= size)
1265                     break;
1266                 }
1267
1268               if (offset >= 0
1269                   && host_integerp (DECL_FIELD_OFFSET (field), 0))
1270                 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1271                           + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1272                             / BITS_PER_UNIT;
1273               else
1274                 {
1275                   offset = -1;
1276                   length = -1;
1277                 }
1278
1279               mem_expr = TREE_OPERAND (mem_expr, 0);
1280               inner = TREE_OPERAND (inner, 0);
1281             }
1282
1283           if (mem_expr == NULL)
1284             offset = -1;
1285           if (mem_expr != MEM_EXPR (mem))
1286             {
1287               set_mem_expr (mem, mem_expr);
1288               set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1289             }
1290         }
1291       set_mem_alias_set (mem, 0);
1292       set_mem_size (mem, NULL_RTX);
1293     }
1294
1295   return mem;
1296 }
1297 \f
1298 /* Built-in functions to perform an untyped call and return.  */
1299
1300 #define apply_args_mode \
1301   (this_target_builtins->x_apply_args_mode)
1302 #define apply_result_mode \
1303   (this_target_builtins->x_apply_result_mode)
1304
1305 /* Return the size required for the block returned by __builtin_apply_args,
1306    and initialize apply_args_mode.  */
1307
1308 static int
1309 apply_args_size (void)
1310 {
1311   static int size = -1;
1312   int align;
1313   unsigned int regno;
1314   enum machine_mode mode;
1315
1316   /* The values computed by this function never change.  */
1317   if (size < 0)
1318     {
1319       /* The first value is the incoming arg-pointer.  */
1320       size = GET_MODE_SIZE (Pmode);
1321
1322       /* The second value is the structure value address unless this is
1323          passed as an "invisible" first argument.  */
1324       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1325         size += GET_MODE_SIZE (Pmode);
1326
1327       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1328         if (FUNCTION_ARG_REGNO_P (regno))
1329           {
1330             mode = targetm.calls.get_raw_arg_mode (regno);
1331
1332             gcc_assert (mode != VOIDmode);
1333
1334             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1335             if (size % align != 0)
1336               size = CEIL (size, align) * align;
1337             size += GET_MODE_SIZE (mode);
1338             apply_args_mode[regno] = mode;
1339           }
1340         else
1341           {
1342             apply_args_mode[regno] = VOIDmode;
1343           }
1344     }
1345   return size;
1346 }
1347
1348 /* Return the size required for the block returned by __builtin_apply,
1349    and initialize apply_result_mode.  */
1350
1351 static int
1352 apply_result_size (void)
1353 {
1354   static int size = -1;
1355   int align, regno;
1356   enum machine_mode mode;
1357
1358   /* The values computed by this function never change.  */
1359   if (size < 0)
1360     {
1361       size = 0;
1362
1363       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1364         if (targetm.calls.function_value_regno_p (regno))
1365           {
1366             mode = targetm.calls.get_raw_result_mode (regno);
1367
1368             gcc_assert (mode != VOIDmode);
1369
1370             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1371             if (size % align != 0)
1372               size = CEIL (size, align) * align;
1373             size += GET_MODE_SIZE (mode);
1374             apply_result_mode[regno] = mode;
1375           }
1376         else
1377           apply_result_mode[regno] = VOIDmode;
1378
1379       /* Allow targets that use untyped_call and untyped_return to override
1380          the size so that machine-specific information can be stored here.  */
1381 #ifdef APPLY_RESULT_SIZE
1382       size = APPLY_RESULT_SIZE;
1383 #endif
1384     }
1385   return size;
1386 }
1387
1388 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1389 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1390    the result block is used to save the values; otherwise it is used to
1391    restore the values.  */
1392
1393 static rtx
1394 result_vector (int savep, rtx result)
1395 {
1396   int regno, size, align, nelts;
1397   enum machine_mode mode;
1398   rtx reg, mem;
1399   rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1400
1401   size = nelts = 0;
1402   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1403     if ((mode = apply_result_mode[regno]) != VOIDmode)
1404       {
1405         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1406         if (size % align != 0)
1407           size = CEIL (size, align) * align;
1408         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1409         mem = adjust_address (result, mode, size);
1410         savevec[nelts++] = (savep
1411                             ? gen_rtx_SET (VOIDmode, mem, reg)
1412                             : gen_rtx_SET (VOIDmode, reg, mem));
1413         size += GET_MODE_SIZE (mode);
1414       }
1415   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1416 }
1417 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1418
1419 /* Save the state required to perform an untyped call with the same
1420    arguments as were passed to the current function.  */
1421
1422 static rtx
1423 expand_builtin_apply_args_1 (void)
1424 {
1425   rtx registers, tem;
1426   int size, align, regno;
1427   enum machine_mode mode;
1428   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1429
1430   /* Create a block where the arg-pointer, structure value address,
1431      and argument registers can be saved.  */
1432   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1433
1434   /* Walk past the arg-pointer and structure value address.  */
1435   size = GET_MODE_SIZE (Pmode);
1436   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1437     size += GET_MODE_SIZE (Pmode);
1438
1439   /* Save each register used in calling a function to the block.  */
1440   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1441     if ((mode = apply_args_mode[regno]) != VOIDmode)
1442       {
1443         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1444         if (size % align != 0)
1445           size = CEIL (size, align) * align;
1446
1447         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1448
1449         emit_move_insn (adjust_address (registers, mode, size), tem);
1450         size += GET_MODE_SIZE (mode);
1451       }
1452
1453   /* Save the arg pointer to the block.  */
1454   tem = copy_to_reg (crtl->args.internal_arg_pointer);
1455 #ifdef STACK_GROWS_DOWNWARD
1456   /* We need the pointer as the caller actually passed them to us, not
1457      as we might have pretended they were passed.  Make sure it's a valid
1458      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1459   tem
1460     = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1461                      NULL_RTX);
1462 #endif
1463   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1464
1465   size = GET_MODE_SIZE (Pmode);
1466
1467   /* Save the structure value address unless this is passed as an
1468      "invisible" first argument.  */
1469   if (struct_incoming_value)
1470     {
1471       emit_move_insn (adjust_address (registers, Pmode, size),
1472                       copy_to_reg (struct_incoming_value));
1473       size += GET_MODE_SIZE (Pmode);
1474     }
1475
1476   /* Return the address of the block.  */
1477   return copy_addr_to_reg (XEXP (registers, 0));
1478 }
1479
1480 /* __builtin_apply_args returns block of memory allocated on
1481    the stack into which is stored the arg pointer, structure
1482    value address, static chain, and all the registers that might
1483    possibly be used in performing a function call.  The code is
1484    moved to the start of the function so the incoming values are
1485    saved.  */
1486
1487 static rtx
1488 expand_builtin_apply_args (void)
1489 {
1490   /* Don't do __builtin_apply_args more than once in a function.
1491      Save the result of the first call and reuse it.  */
1492   if (apply_args_value != 0)
1493     return apply_args_value;
1494   {
1495     /* When this function is called, it means that registers must be
1496        saved on entry to this function.  So we migrate the
1497        call to the first insn of this function.  */
1498     rtx temp;
1499     rtx seq;
1500
1501     start_sequence ();
1502     temp = expand_builtin_apply_args_1 ();
1503     seq = get_insns ();
1504     end_sequence ();
1505
1506     apply_args_value = temp;
1507
1508     /* Put the insns after the NOTE that starts the function.
1509        If this is inside a start_sequence, make the outer-level insn
1510        chain current, so the code is placed at the start of the
1511        function.  If internal_arg_pointer is a non-virtual pseudo,
1512        it needs to be placed after the function that initializes
1513        that pseudo.  */
1514     push_topmost_sequence ();
1515     if (REG_P (crtl->args.internal_arg_pointer)
1516         && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1517       emit_insn_before (seq, parm_birth_insn);
1518     else
1519       emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1520     pop_topmost_sequence ();
1521     return temp;
1522   }
1523 }
1524
1525 /* Perform an untyped call and save the state required to perform an
1526    untyped return of whatever value was returned by the given function.  */
1527
1528 static rtx
1529 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1530 {
1531   int size, align, regno;
1532   enum machine_mode mode;
1533   rtx incoming_args, result, reg, dest, src, call_insn;
1534   rtx old_stack_level = 0;
1535   rtx call_fusage = 0;
1536   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1537
1538   arguments = convert_memory_address (Pmode, arguments);
1539
1540   /* Create a block where the return registers can be saved.  */
1541   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1542
1543   /* Fetch the arg pointer from the ARGUMENTS block.  */
1544   incoming_args = gen_reg_rtx (Pmode);
1545   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1546 #ifndef STACK_GROWS_DOWNWARD
1547   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1548                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1549 #endif
1550
1551   /* Push a new argument block and copy the arguments.  Do not allow
1552      the (potential) memcpy call below to interfere with our stack
1553      manipulations.  */
1554   do_pending_stack_adjust ();
1555   NO_DEFER_POP;
1556
1557   /* Save the stack with nonlocal if available.  */
1558 #ifdef HAVE_save_stack_nonlocal
1559   if (HAVE_save_stack_nonlocal)
1560     emit_stack_save (SAVE_NONLOCAL, &old_stack_level);
1561   else
1562 #endif
1563     emit_stack_save (SAVE_BLOCK, &old_stack_level);
1564
1565   /* Allocate a block of memory onto the stack and copy the memory
1566      arguments to the outgoing arguments address.  We can pass TRUE
1567      as the 4th argument because we just saved the stack pointer
1568      and will restore it right after the call.  */
1569   allocate_dynamic_stack_space (argsize, 0, BIGGEST_ALIGNMENT, true);
1570
1571   /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1572      may have already set current_function_calls_alloca to true.
1573      current_function_calls_alloca won't be set if argsize is zero,
1574      so we have to guarantee need_drap is true here.  */
1575   if (SUPPORTS_STACK_ALIGNMENT)
1576     crtl->need_drap = true;
1577
1578   dest = virtual_outgoing_args_rtx;
1579 #ifndef STACK_GROWS_DOWNWARD
1580   if (CONST_INT_P (argsize))
1581     dest = plus_constant (dest, -INTVAL (argsize));
1582   else
1583     dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1584 #endif
1585   dest = gen_rtx_MEM (BLKmode, dest);
1586   set_mem_align (dest, PARM_BOUNDARY);
1587   src = gen_rtx_MEM (BLKmode, incoming_args);
1588   set_mem_align (src, PARM_BOUNDARY);
1589   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1590
1591   /* Refer to the argument block.  */
1592   apply_args_size ();
1593   arguments = gen_rtx_MEM (BLKmode, arguments);
1594   set_mem_align (arguments, PARM_BOUNDARY);
1595
1596   /* Walk past the arg-pointer and structure value address.  */
1597   size = GET_MODE_SIZE (Pmode);
1598   if (struct_value)
1599     size += GET_MODE_SIZE (Pmode);
1600
1601   /* Restore each of the registers previously saved.  Make USE insns
1602      for each of these registers for use in making the call.  */
1603   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1604     if ((mode = apply_args_mode[regno]) != VOIDmode)
1605       {
1606         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1607         if (size % align != 0)
1608           size = CEIL (size, align) * align;
1609         reg = gen_rtx_REG (mode, regno);
1610         emit_move_insn (reg, adjust_address (arguments, mode, size));
1611         use_reg (&call_fusage, reg);
1612         size += GET_MODE_SIZE (mode);
1613       }
1614
1615   /* Restore the structure value address unless this is passed as an
1616      "invisible" first argument.  */
1617   size = GET_MODE_SIZE (Pmode);
1618   if (struct_value)
1619     {
1620       rtx value = gen_reg_rtx (Pmode);
1621       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1622       emit_move_insn (struct_value, value);
1623       if (REG_P (struct_value))
1624         use_reg (&call_fusage, struct_value);
1625       size += GET_MODE_SIZE (Pmode);
1626     }
1627
1628   /* All arguments and registers used for the call are set up by now!  */
1629   function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1630
1631   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1632      and we don't want to load it into a register as an optimization,
1633      because prepare_call_address already did it if it should be done.  */
1634   if (GET_CODE (function) != SYMBOL_REF)
1635     function = memory_address (FUNCTION_MODE, function);
1636
1637   /* Generate the actual call instruction and save the return value.  */
1638 #ifdef HAVE_untyped_call
1639   if (HAVE_untyped_call)
1640     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1641                                       result, result_vector (1, result)));
1642   else
1643 #endif
1644 #ifdef HAVE_call_value
1645   if (HAVE_call_value)
1646     {
1647       rtx valreg = 0;
1648
1649       /* Locate the unique return register.  It is not possible to
1650          express a call that sets more than one return register using
1651          call_value; use untyped_call for that.  In fact, untyped_call
1652          only needs to save the return registers in the given block.  */
1653       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1654         if ((mode = apply_result_mode[regno]) != VOIDmode)
1655           {
1656             gcc_assert (!valreg); /* HAVE_untyped_call required.  */
1657
1658             valreg = gen_rtx_REG (mode, regno);
1659           }
1660
1661       emit_call_insn (GEN_CALL_VALUE (valreg,
1662                                       gen_rtx_MEM (FUNCTION_MODE, function),
1663                                       const0_rtx, NULL_RTX, const0_rtx));
1664
1665       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1666     }
1667   else
1668 #endif
1669     gcc_unreachable ();
1670
1671   /* Find the CALL insn we just emitted, and attach the register usage
1672      information.  */
1673   call_insn = last_call_insn ();
1674   add_function_usage_to (call_insn, call_fusage);
1675
1676   /* Restore the stack.  */
1677 #ifdef HAVE_save_stack_nonlocal
1678   if (HAVE_save_stack_nonlocal)
1679     emit_stack_restore (SAVE_NONLOCAL, old_stack_level);
1680   else
1681 #endif
1682     emit_stack_restore (SAVE_BLOCK, old_stack_level);
1683
1684   OK_DEFER_POP;
1685
1686   /* Return the address of the result block.  */
1687   result = copy_addr_to_reg (XEXP (result, 0));
1688   return convert_memory_address (ptr_mode, result);
1689 }
1690
1691 /* Perform an untyped return.  */
1692
1693 static void
1694 expand_builtin_return (rtx result)
1695 {
1696   int size, align, regno;
1697   enum machine_mode mode;
1698   rtx reg;
1699   rtx call_fusage = 0;
1700
1701   result = convert_memory_address (Pmode, result);
1702
1703   apply_result_size ();
1704   result = gen_rtx_MEM (BLKmode, result);
1705
1706 #ifdef HAVE_untyped_return
1707   if (HAVE_untyped_return)
1708     {
1709       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1710       emit_barrier ();
1711       return;
1712     }
1713 #endif
1714
1715   /* Restore the return value and note that each value is used.  */
1716   size = 0;
1717   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1718     if ((mode = apply_result_mode[regno]) != VOIDmode)
1719       {
1720         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1721         if (size % align != 0)
1722           size = CEIL (size, align) * align;
1723         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1724         emit_move_insn (reg, adjust_address (result, mode, size));
1725
1726         push_to_sequence (call_fusage);
1727         emit_use (reg);
1728         call_fusage = get_insns ();
1729         end_sequence ();
1730         size += GET_MODE_SIZE (mode);
1731       }
1732
1733   /* Put the USE insns before the return.  */
1734   emit_insn (call_fusage);
1735
1736   /* Return whatever values was restored by jumping directly to the end
1737      of the function.  */
1738   expand_naked_return ();
1739 }
1740
1741 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1742
1743 static enum type_class
1744 type_to_class (tree type)
1745 {
1746   switch (TREE_CODE (type))
1747     {
1748     case VOID_TYPE:        return void_type_class;
1749     case INTEGER_TYPE:     return integer_type_class;
1750     case ENUMERAL_TYPE:    return enumeral_type_class;
1751     case BOOLEAN_TYPE:     return boolean_type_class;
1752     case POINTER_TYPE:     return pointer_type_class;
1753     case REFERENCE_TYPE:   return reference_type_class;
1754     case OFFSET_TYPE:      return offset_type_class;
1755     case REAL_TYPE:        return real_type_class;
1756     case COMPLEX_TYPE:     return complex_type_class;
1757     case FUNCTION_TYPE:    return function_type_class;
1758     case METHOD_TYPE:      return method_type_class;
1759     case RECORD_TYPE:      return record_type_class;
1760     case UNION_TYPE:
1761     case QUAL_UNION_TYPE:  return union_type_class;
1762     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1763                                    ? string_type_class : array_type_class);
1764     case LANG_TYPE:        return lang_type_class;
1765     default:               return no_type_class;
1766     }
1767 }
1768
1769 /* Expand a call EXP to __builtin_classify_type.  */
1770
1771 static rtx
1772 expand_builtin_classify_type (tree exp)
1773 {
1774   if (call_expr_nargs (exp))
1775     return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1776   return GEN_INT (no_type_class);
1777 }
1778
1779 /* This helper macro, meant to be used in mathfn_built_in below,
1780    determines which among a set of three builtin math functions is
1781    appropriate for a given type mode.  The `F' and `L' cases are
1782    automatically generated from the `double' case.  */
1783 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1784   case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1785   fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1786   fcodel = BUILT_IN_MATHFN##L ; break;
1787 /* Similar to above, but appends _R after any F/L suffix.  */
1788 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1789   case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1790   fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1791   fcodel = BUILT_IN_MATHFN##L_R ; break;
1792
1793 /* Return mathematic function equivalent to FN but operating directly
1794    on TYPE, if available.  If IMPLICIT is true find the function in
1795    implicit_built_in_decls[], otherwise use built_in_decls[].  If we
1796    can't do the conversion, return zero.  */
1797
1798 static tree
1799 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit)
1800 {
1801   tree const *const fn_arr
1802     = implicit ? implicit_built_in_decls : built_in_decls;
1803   enum built_in_function fcode, fcodef, fcodel;
1804
1805   switch (fn)
1806     {
1807       CASE_MATHFN (BUILT_IN_ACOS)
1808       CASE_MATHFN (BUILT_IN_ACOSH)
1809       CASE_MATHFN (BUILT_IN_ASIN)
1810       CASE_MATHFN (BUILT_IN_ASINH)
1811       CASE_MATHFN (BUILT_IN_ATAN)
1812       CASE_MATHFN (BUILT_IN_ATAN2)
1813       CASE_MATHFN (BUILT_IN_ATANH)
1814       CASE_MATHFN (BUILT_IN_CBRT)
1815       CASE_MATHFN (BUILT_IN_CEIL)
1816       CASE_MATHFN (BUILT_IN_CEXPI)
1817       CASE_MATHFN (BUILT_IN_COPYSIGN)
1818       CASE_MATHFN (BUILT_IN_COS)
1819       CASE_MATHFN (BUILT_IN_COSH)
1820       CASE_MATHFN (BUILT_IN_DREM)
1821       CASE_MATHFN (BUILT_IN_ERF)
1822       CASE_MATHFN (BUILT_IN_ERFC)
1823       CASE_MATHFN (BUILT_IN_EXP)
1824       CASE_MATHFN (BUILT_IN_EXP10)
1825       CASE_MATHFN (BUILT_IN_EXP2)
1826       CASE_MATHFN (BUILT_IN_EXPM1)
1827       CASE_MATHFN (BUILT_IN_FABS)
1828       CASE_MATHFN (BUILT_IN_FDIM)
1829       CASE_MATHFN (BUILT_IN_FLOOR)
1830       CASE_MATHFN (BUILT_IN_FMA)
1831       CASE_MATHFN (BUILT_IN_FMAX)
1832       CASE_MATHFN (BUILT_IN_FMIN)
1833       CASE_MATHFN (BUILT_IN_FMOD)
1834       CASE_MATHFN (BUILT_IN_FREXP)
1835       CASE_MATHFN (BUILT_IN_GAMMA)
1836       CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1837       CASE_MATHFN (BUILT_IN_HUGE_VAL)
1838       CASE_MATHFN (BUILT_IN_HYPOT)
1839       CASE_MATHFN (BUILT_IN_ILOGB)
1840       CASE_MATHFN (BUILT_IN_INF)
1841       CASE_MATHFN (BUILT_IN_ISINF)
1842       CASE_MATHFN (BUILT_IN_J0)
1843       CASE_MATHFN (BUILT_IN_J1)
1844       CASE_MATHFN (BUILT_IN_JN)
1845       CASE_MATHFN (BUILT_IN_LCEIL)
1846       CASE_MATHFN (BUILT_IN_LDEXP)
1847       CASE_MATHFN (BUILT_IN_LFLOOR)
1848       CASE_MATHFN (BUILT_IN_LGAMMA)
1849       CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1850       CASE_MATHFN (BUILT_IN_LLCEIL)
1851       CASE_MATHFN (BUILT_IN_LLFLOOR)
1852       CASE_MATHFN (BUILT_IN_LLRINT)
1853       CASE_MATHFN (BUILT_IN_LLROUND)
1854       CASE_MATHFN (BUILT_IN_LOG)
1855       CASE_MATHFN (BUILT_IN_LOG10)
1856       CASE_MATHFN (BUILT_IN_LOG1P)
1857       CASE_MATHFN (BUILT_IN_LOG2)
1858       CASE_MATHFN (BUILT_IN_LOGB)
1859       CASE_MATHFN (BUILT_IN_LRINT)
1860       CASE_MATHFN (BUILT_IN_LROUND)
1861       CASE_MATHFN (BUILT_IN_MODF)
1862       CASE_MATHFN (BUILT_IN_NAN)
1863       CASE_MATHFN (BUILT_IN_NANS)
1864       CASE_MATHFN (BUILT_IN_NEARBYINT)
1865       CASE_MATHFN (BUILT_IN_NEXTAFTER)
1866       CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1867       CASE_MATHFN (BUILT_IN_POW)
1868       CASE_MATHFN (BUILT_IN_POWI)
1869       CASE_MATHFN (BUILT_IN_POW10)
1870       CASE_MATHFN (BUILT_IN_REMAINDER)
1871       CASE_MATHFN (BUILT_IN_REMQUO)
1872       CASE_MATHFN (BUILT_IN_RINT)
1873       CASE_MATHFN (BUILT_IN_ROUND)
1874       CASE_MATHFN (BUILT_IN_SCALB)
1875       CASE_MATHFN (BUILT_IN_SCALBLN)
1876       CASE_MATHFN (BUILT_IN_SCALBN)
1877       CASE_MATHFN (BUILT_IN_SIGNBIT)
1878       CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1879       CASE_MATHFN (BUILT_IN_SIN)
1880       CASE_MATHFN (BUILT_IN_SINCOS)
1881       CASE_MATHFN (BUILT_IN_SINH)
1882       CASE_MATHFN (BUILT_IN_SQRT)
1883       CASE_MATHFN (BUILT_IN_TAN)
1884       CASE_MATHFN (BUILT_IN_TANH)
1885       CASE_MATHFN (BUILT_IN_TGAMMA)
1886       CASE_MATHFN (BUILT_IN_TRUNC)
1887       CASE_MATHFN (BUILT_IN_Y0)
1888       CASE_MATHFN (BUILT_IN_Y1)
1889       CASE_MATHFN (BUILT_IN_YN)
1890
1891       default:
1892         return NULL_TREE;
1893       }
1894
1895   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1896     return fn_arr[fcode];
1897   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1898     return fn_arr[fcodef];
1899   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1900     return fn_arr[fcodel];
1901   else
1902     return NULL_TREE;
1903 }
1904
1905 /* Like mathfn_built_in_1(), but always use the implicit array.  */
1906
1907 tree
1908 mathfn_built_in (tree type, enum built_in_function fn)
1909 {
1910   return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1911 }
1912
1913 /* If errno must be maintained, expand the RTL to check if the result,
1914    TARGET, of a built-in function call, EXP, is NaN, and if so set
1915    errno to EDOM.  */
1916
1917 static void
1918 expand_errno_check (tree exp, rtx target)
1919 {
1920   rtx lab = gen_label_rtx ();
1921
1922   /* Test the result; if it is NaN, set errno=EDOM because
1923      the argument was not in the domain.  */
1924   do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1925                            NULL_RTX, NULL_RTX, lab,
1926                            /* The jump is very likely.  */
1927                            REG_BR_PROB_BASE - (REG_BR_PROB_BASE / 2000 - 1));
1928
1929 #ifdef TARGET_EDOM
1930   /* If this built-in doesn't throw an exception, set errno directly.  */
1931   if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1932     {
1933 #ifdef GEN_ERRNO_RTX
1934       rtx errno_rtx = GEN_ERRNO_RTX;
1935 #else
1936       rtx errno_rtx
1937           = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1938 #endif
1939       emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1940       emit_label (lab);
1941       return;
1942     }
1943 #endif
1944
1945   /* Make sure the library call isn't expanded as a tail call.  */
1946   CALL_EXPR_TAILCALL (exp) = 0;
1947
1948   /* We can't set errno=EDOM directly; let the library call do it.
1949      Pop the arguments right away in case the call gets deleted.  */
1950   NO_DEFER_POP;
1951   expand_call (exp, target, 0);
1952   OK_DEFER_POP;
1953   emit_label (lab);
1954 }
1955
1956 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1957    Return NULL_RTX if a normal call should be emitted rather than expanding
1958    the function in-line.  EXP is the expression that is a call to the builtin
1959    function; if convenient, the result should be placed in TARGET.
1960    SUBTARGET may be used as the target for computing one of EXP's operands.  */
1961
1962 static rtx
1963 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1964 {
1965   optab builtin_optab;
1966   rtx op0, insns;
1967   tree fndecl = get_callee_fndecl (exp);
1968   enum machine_mode mode;
1969   bool errno_set = false;
1970   tree arg;
1971
1972   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1973     return NULL_RTX;
1974
1975   arg = CALL_EXPR_ARG (exp, 0);
1976
1977   switch (DECL_FUNCTION_CODE (fndecl))
1978     {
1979     CASE_FLT_FN (BUILT_IN_SQRT):
1980       errno_set = ! tree_expr_nonnegative_p (arg);
1981       builtin_optab = sqrt_optab;
1982       break;
1983     CASE_FLT_FN (BUILT_IN_EXP):
1984       errno_set = true; builtin_optab = exp_optab; break;
1985     CASE_FLT_FN (BUILT_IN_EXP10):
1986     CASE_FLT_FN (BUILT_IN_POW10):
1987       errno_set = true; builtin_optab = exp10_optab; break;
1988     CASE_FLT_FN (BUILT_IN_EXP2):
1989       errno_set = true; builtin_optab = exp2_optab; break;
1990     CASE_FLT_FN (BUILT_IN_EXPM1):
1991       errno_set = true; builtin_optab = expm1_optab; break;
1992     CASE_FLT_FN (BUILT_IN_LOGB):
1993       errno_set = true; builtin_optab = logb_optab; break;
1994     CASE_FLT_FN (BUILT_IN_LOG):
1995       errno_set = true; builtin_optab = log_optab; break;
1996     CASE_FLT_FN (BUILT_IN_LOG10):
1997       errno_set = true; builtin_optab = log10_optab; break;
1998     CASE_FLT_FN (BUILT_IN_LOG2):
1999       errno_set = true; builtin_optab = log2_optab; break;
2000     CASE_FLT_FN (BUILT_IN_LOG1P):
2001       errno_set = true; builtin_optab = log1p_optab; break;
2002     CASE_FLT_FN (BUILT_IN_ASIN):
2003       builtin_optab = asin_optab; break;
2004     CASE_FLT_FN (BUILT_IN_ACOS):
2005       builtin_optab = acos_optab; break;
2006     CASE_FLT_FN (BUILT_IN_TAN):
2007       builtin_optab = tan_optab; break;
2008     CASE_FLT_FN (BUILT_IN_ATAN):
2009       builtin_optab = atan_optab; break;
2010     CASE_FLT_FN (BUILT_IN_FLOOR):
2011       builtin_optab = floor_optab; break;
2012     CASE_FLT_FN (BUILT_IN_CEIL):
2013       builtin_optab = ceil_optab; break;
2014     CASE_FLT_FN (BUILT_IN_TRUNC):
2015       builtin_optab = btrunc_optab; break;
2016     CASE_FLT_FN (BUILT_IN_ROUND):
2017       builtin_optab = round_optab; break;
2018     CASE_FLT_FN (BUILT_IN_NEARBYINT):
2019       builtin_optab = nearbyint_optab;
2020       if (flag_trapping_math)
2021         break;
2022       /* Else fallthrough and expand as rint.  */
2023     CASE_FLT_FN (BUILT_IN_RINT):
2024       builtin_optab = rint_optab; break;
2025     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
2026       builtin_optab = significand_optab; break;
2027     default:
2028       gcc_unreachable ();
2029     }
2030
2031   /* Make a suitable register to place result in.  */
2032   mode = TYPE_MODE (TREE_TYPE (exp));
2033
2034   if (! flag_errno_math || ! HONOR_NANS (mode))
2035     errno_set = false;
2036
2037   /* Before working hard, check whether the instruction is available.  */
2038   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing
2039       && (!errno_set || !optimize_insn_for_size_p ()))
2040     {
2041       target = gen_reg_rtx (mode);
2042
2043       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2044          need to expand the argument again.  This way, we will not perform
2045          side-effects more the once.  */
2046       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2047
2048       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2049
2050       start_sequence ();
2051
2052       /* Compute into TARGET.
2053          Set TARGET to wherever the result comes back.  */
2054       target = expand_unop (mode, builtin_optab, op0, target, 0);
2055
2056       if (target != 0)
2057         {
2058           if (errno_set)
2059             expand_errno_check (exp, target);
2060
2061           /* Output the entire sequence.  */
2062           insns = get_insns ();
2063           end_sequence ();
2064           emit_insn (insns);
2065           return target;
2066         }
2067
2068       /* If we were unable to expand via the builtin, stop the sequence
2069          (without outputting the insns) and call to the library function
2070          with the stabilized argument list.  */
2071       end_sequence ();
2072     }
2073
2074   return expand_call (exp, target, target == const0_rtx);
2075 }
2076
2077 /* Expand a call to the builtin binary math functions (pow and atan2).
2078    Return NULL_RTX if a normal call should be emitted rather than expanding the
2079    function in-line.  EXP is the expression that is a call to the builtin
2080    function; if convenient, the result should be placed in TARGET.
2081    SUBTARGET may be used as the target for computing one of EXP's
2082    operands.  */
2083
2084 static rtx
2085 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2086 {
2087   optab builtin_optab;
2088   rtx op0, op1, insns;
2089   int op1_type = REAL_TYPE;
2090   tree fndecl = get_callee_fndecl (exp);
2091   tree arg0, arg1;
2092   enum machine_mode mode;
2093   bool errno_set = true;
2094
2095   switch (DECL_FUNCTION_CODE (fndecl))
2096     {
2097     CASE_FLT_FN (BUILT_IN_SCALBN):
2098     CASE_FLT_FN (BUILT_IN_SCALBLN):
2099     CASE_FLT_FN (BUILT_IN_LDEXP):
2100       op1_type = INTEGER_TYPE;
2101     default:
2102       break;
2103     }
2104
2105   if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2106     return NULL_RTX;
2107
2108   arg0 = CALL_EXPR_ARG (exp, 0);
2109   arg1 = CALL_EXPR_ARG (exp, 1);
2110
2111   switch (DECL_FUNCTION_CODE (fndecl))
2112     {
2113     CASE_FLT_FN (BUILT_IN_POW):
2114       builtin_optab = pow_optab; break;
2115     CASE_FLT_FN (BUILT_IN_ATAN2):
2116       builtin_optab = atan2_optab; break;
2117     CASE_FLT_FN (BUILT_IN_SCALB):
2118       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2119         return 0;
2120       builtin_optab = scalb_optab; break;
2121     CASE_FLT_FN (BUILT_IN_SCALBN):
2122     CASE_FLT_FN (BUILT_IN_SCALBLN):
2123       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2124         return 0;
2125     /* Fall through... */
2126     CASE_FLT_FN (BUILT_IN_LDEXP):
2127       builtin_optab = ldexp_optab; break;
2128     CASE_FLT_FN (BUILT_IN_FMOD):
2129       builtin_optab = fmod_optab; break;
2130     CASE_FLT_FN (BUILT_IN_REMAINDER):
2131     CASE_FLT_FN (BUILT_IN_DREM):
2132       builtin_optab = remainder_optab; break;
2133     default:
2134       gcc_unreachable ();
2135     }
2136
2137   /* Make a suitable register to place result in.  */
2138   mode = TYPE_MODE (TREE_TYPE (exp));
2139
2140   /* Before working hard, check whether the instruction is available.  */
2141   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2142     return NULL_RTX;
2143
2144   target = gen_reg_rtx (mode);
2145
2146   if (! flag_errno_math || ! HONOR_NANS (mode))
2147     errno_set = false;
2148
2149   if (errno_set && optimize_insn_for_size_p ())
2150     return 0;
2151
2152   /* Always stabilize the argument list.  */
2153   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2154   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2155
2156   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2157   op1 = expand_normal (arg1);
2158
2159   start_sequence ();
2160
2161   /* Compute into TARGET.
2162      Set TARGET to wherever the result comes back.  */
2163   target = expand_binop (mode, builtin_optab, op0, op1,
2164                          target, 0, OPTAB_DIRECT);
2165
2166   /* If we were unable to expand via the builtin, stop the sequence
2167      (without outputting the insns) and call to the library function
2168      with the stabilized argument list.  */
2169   if (target == 0)
2170     {
2171       end_sequence ();
2172       return expand_call (exp, target, target == const0_rtx);
2173     }
2174
2175   if (errno_set)
2176     expand_errno_check (exp, target);
2177
2178   /* Output the entire sequence.  */
2179   insns = get_insns ();
2180   end_sequence ();
2181   emit_insn (insns);
2182
2183   return target;
2184 }
2185
2186 /* Expand a call to the builtin trinary math functions (fma).
2187    Return NULL_RTX if a normal call should be emitted rather than expanding the
2188    function in-line.  EXP is the expression that is a call to the builtin
2189    function; if convenient, the result should be placed in TARGET.
2190    SUBTARGET may be used as the target for computing one of EXP's
2191    operands.  */
2192
2193 static rtx
2194 expand_builtin_mathfn_ternary (tree exp, rtx target, rtx subtarget)
2195 {
2196   optab builtin_optab;
2197   rtx op0, op1, op2, insns;
2198   tree fndecl = get_callee_fndecl (exp);
2199   tree arg0, arg1, arg2;
2200   enum machine_mode mode;
2201
2202   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2203     return NULL_RTX;
2204
2205   arg0 = CALL_EXPR_ARG (exp, 0);
2206   arg1 = CALL_EXPR_ARG (exp, 1);
2207   arg2 = CALL_EXPR_ARG (exp, 2);
2208
2209   switch (DECL_FUNCTION_CODE (fndecl))
2210     {
2211     CASE_FLT_FN (BUILT_IN_FMA):
2212       builtin_optab = fma_optab; break;
2213     default:
2214       gcc_unreachable ();
2215     }
2216
2217   /* Make a suitable register to place result in.  */
2218   mode = TYPE_MODE (TREE_TYPE (exp));
2219
2220   /* Before working hard, check whether the instruction is available.  */
2221   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2222     return NULL_RTX;
2223
2224   target = gen_reg_rtx (mode);
2225
2226   /* Always stabilize the argument list.  */
2227   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2228   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2229   CALL_EXPR_ARG (exp, 2) = arg2 = builtin_save_expr (arg2);
2230
2231   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2232   op1 = expand_normal (arg1);
2233   op2 = expand_normal (arg2);
2234
2235   start_sequence ();
2236
2237   /* Compute into TARGET.
2238      Set TARGET to wherever the result comes back.  */
2239   target = expand_ternary_op (mode, builtin_optab, op0, op1, op2,
2240                               target, 0);
2241
2242   /* If we were unable to expand via the builtin, stop the sequence
2243      (without outputting the insns) and call to the library function
2244      with the stabilized argument list.  */
2245   if (target == 0)
2246     {
2247       end_sequence ();
2248       return expand_call (exp, target, target == const0_rtx);
2249     }
2250
2251   /* Output the entire sequence.  */
2252   insns = get_insns ();
2253   end_sequence ();
2254   emit_insn (insns);
2255
2256   return target;
2257 }
2258
2259 /* Expand a call to the builtin sin and cos math functions.
2260    Return NULL_RTX if a normal call should be emitted rather than expanding the
2261    function in-line.  EXP is the expression that is a call to the builtin
2262    function; if convenient, the result should be placed in TARGET.
2263    SUBTARGET may be used as the target for computing one of EXP's
2264    operands.  */
2265
2266 static rtx
2267 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2268 {
2269   optab builtin_optab;
2270   rtx op0, insns;
2271   tree fndecl = get_callee_fndecl (exp);
2272   enum machine_mode mode;
2273   tree arg;
2274
2275   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2276     return NULL_RTX;
2277
2278   arg = CALL_EXPR_ARG (exp, 0);
2279
2280   switch (DECL_FUNCTION_CODE (fndecl))
2281     {
2282     CASE_FLT_FN (BUILT_IN_SIN):
2283     CASE_FLT_FN (BUILT_IN_COS):
2284       builtin_optab = sincos_optab; break;
2285     default:
2286       gcc_unreachable ();
2287     }
2288
2289   /* Make a suitable register to place result in.  */
2290   mode = TYPE_MODE (TREE_TYPE (exp));
2291
2292   /* Check if sincos insn is available, otherwise fallback
2293      to sin or cos insn.  */
2294   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2295     switch (DECL_FUNCTION_CODE (fndecl))
2296       {
2297       CASE_FLT_FN (BUILT_IN_SIN):
2298         builtin_optab = sin_optab; break;
2299       CASE_FLT_FN (BUILT_IN_COS):
2300         builtin_optab = cos_optab; break;
2301       default:
2302         gcc_unreachable ();
2303       }
2304
2305   /* Before working hard, check whether the instruction is available.  */
2306   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2307     {
2308       target = gen_reg_rtx (mode);
2309
2310       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2311          need to expand the argument again.  This way, we will not perform
2312          side-effects more the once.  */
2313       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2314
2315       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2316
2317       start_sequence ();
2318
2319       /* Compute into TARGET.
2320          Set TARGET to wherever the result comes back.  */
2321       if (builtin_optab == sincos_optab)
2322         {
2323           int result;
2324
2325           switch (DECL_FUNCTION_CODE (fndecl))
2326             {
2327             CASE_FLT_FN (BUILT_IN_SIN):
2328               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2329               break;
2330             CASE_FLT_FN (BUILT_IN_COS):
2331               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2332               break;
2333             default:
2334               gcc_unreachable ();
2335             }
2336           gcc_assert (result);
2337         }
2338       else
2339         {
2340           target = expand_unop (mode, builtin_optab, op0, target, 0);
2341         }
2342
2343       if (target != 0)
2344         {
2345           /* Output the entire sequence.  */
2346           insns = get_insns ();
2347           end_sequence ();
2348           emit_insn (insns);
2349           return target;
2350         }
2351
2352       /* If we were unable to expand via the builtin, stop the sequence
2353          (without outputting the insns) and call to the library function
2354          with the stabilized argument list.  */
2355       end_sequence ();
2356     }
2357
2358   target = expand_call (exp, target, target == const0_rtx);
2359
2360   return target;
2361 }
2362
2363 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2364    return an RTL instruction code that implements the functionality.
2365    If that isn't possible or available return CODE_FOR_nothing.  */
2366
2367 static enum insn_code
2368 interclass_mathfn_icode (tree arg, tree fndecl)
2369 {
2370   bool errno_set = false;
2371   optab builtin_optab = 0;
2372   enum machine_mode mode;
2373
2374   switch (DECL_FUNCTION_CODE (fndecl))
2375     {
2376     CASE_FLT_FN (BUILT_IN_ILOGB):
2377       errno_set = true; builtin_optab = ilogb_optab; break;
2378     CASE_FLT_FN (BUILT_IN_ISINF):
2379       builtin_optab = isinf_optab; break;
2380     case BUILT_IN_ISNORMAL:
2381     case BUILT_IN_ISFINITE:
2382     CASE_FLT_FN (BUILT_IN_FINITE):
2383     case BUILT_IN_FINITED32:
2384     case BUILT_IN_FINITED64:
2385     case BUILT_IN_FINITED128:
2386     case BUILT_IN_ISINFD32:
2387     case BUILT_IN_ISINFD64:
2388     case BUILT_IN_ISINFD128:
2389       /* These builtins have no optabs (yet).  */
2390       break;
2391     default:
2392       gcc_unreachable ();
2393     }
2394
2395   /* There's no easy way to detect the case we need to set EDOM.  */
2396   if (flag_errno_math && errno_set)
2397     return CODE_FOR_nothing;
2398
2399   /* Optab mode depends on the mode of the input argument.  */
2400   mode = TYPE_MODE (TREE_TYPE (arg));
2401
2402   if (builtin_optab)
2403     return optab_handler (builtin_optab, mode);
2404   return CODE_FOR_nothing;
2405 }
2406
2407 /* Expand a call to one of the builtin math functions that operate on
2408    floating point argument and output an integer result (ilogb, isinf,
2409    isnan, etc).
2410    Return 0 if a normal call should be emitted rather than expanding the
2411    function in-line.  EXP is the expression that is a call to the builtin
2412    function; if convenient, the result should be placed in TARGET.  */
2413
2414 static rtx
2415 expand_builtin_interclass_mathfn (tree exp, rtx target)
2416 {
2417   enum insn_code icode = CODE_FOR_nothing;
2418   rtx op0;
2419   tree fndecl = get_callee_fndecl (exp);
2420   enum machine_mode mode;
2421   tree arg;
2422
2423   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2424     return NULL_RTX;
2425
2426   arg = CALL_EXPR_ARG (exp, 0);
2427   icode = interclass_mathfn_icode (arg, fndecl);
2428   mode = TYPE_MODE (TREE_TYPE (arg));
2429
2430   if (icode != CODE_FOR_nothing)
2431     {
2432       struct expand_operand ops[1];
2433       rtx last = get_last_insn ();
2434       tree orig_arg = arg;
2435
2436       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2437          need to expand the argument again.  This way, we will not perform
2438          side-effects more the once.  */
2439       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2440
2441       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2442
2443       if (mode != GET_MODE (op0))
2444         op0 = convert_to_mode (mode, op0, 0);
2445
2446       create_output_operand (&ops[0], target, TYPE_MODE (TREE_TYPE (exp)));
2447       if (maybe_legitimize_operands (icode, 0, 1, ops)
2448           && maybe_emit_unop_insn (icode, ops[0].value, op0, UNKNOWN))
2449         return ops[0].value;
2450
2451       delete_insns_since (last);
2452       CALL_EXPR_ARG (exp, 0) = orig_arg;
2453     }
2454
2455   return NULL_RTX;
2456 }
2457
2458 /* Expand a call to the builtin sincos math function.
2459    Return NULL_RTX if a normal call should be emitted rather than expanding the
2460    function in-line.  EXP is the expression that is a call to the builtin
2461    function.  */
2462
2463 static rtx
2464 expand_builtin_sincos (tree exp)
2465 {
2466   rtx op0, op1, op2, target1, target2;
2467   enum machine_mode mode;
2468   tree arg, sinp, cosp;
2469   int result;
2470   location_t loc = EXPR_LOCATION (exp);
2471   tree alias_type, alias_off;
2472
2473   if (!validate_arglist (exp, REAL_TYPE,
2474                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2475     return NULL_RTX;
2476
2477   arg = CALL_EXPR_ARG (exp, 0);
2478   sinp = CALL_EXPR_ARG (exp, 1);
2479   cosp = CALL_EXPR_ARG (exp, 2);
2480
2481   /* Make a suitable register to place result in.  */
2482   mode = TYPE_MODE (TREE_TYPE (arg));
2483
2484   /* Check if sincos insn is available, otherwise emit the call.  */
2485   if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2486     return NULL_RTX;
2487
2488   target1 = gen_reg_rtx (mode);
2489   target2 = gen_reg_rtx (mode);
2490
2491   op0 = expand_normal (arg);
2492   alias_type = build_pointer_type_for_mode (TREE_TYPE (arg), ptr_mode, true);
2493   alias_off = build_int_cst (alias_type, 0);
2494   op1 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2495                                         sinp, alias_off));
2496   op2 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2497                                         cosp, alias_off));
2498
2499   /* Compute into target1 and target2.
2500      Set TARGET to wherever the result comes back.  */
2501   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2502   gcc_assert (result);
2503
2504   /* Move target1 and target2 to the memory locations indicated
2505      by op1 and op2.  */
2506   emit_move_insn (op1, target1);
2507   emit_move_insn (op2, target2);
2508
2509   return const0_rtx;
2510 }
2511
2512 /* Expand a call to the internal cexpi builtin to the sincos math function.
2513    EXP is the expression that is a call to the builtin function; if convenient,
2514    the result should be placed in TARGET.  */
2515
2516 static rtx
2517 expand_builtin_cexpi (tree exp, rtx target)
2518 {
2519   tree fndecl = get_callee_fndecl (exp);
2520   tree arg, type;
2521   enum machine_mode mode;
2522   rtx op0, op1, op2;
2523   location_t loc = EXPR_LOCATION (exp);
2524
2525   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2526     return NULL_RTX;
2527
2528   arg = CALL_EXPR_ARG (exp, 0);
2529   type = TREE_TYPE (arg);
2530   mode = TYPE_MODE (TREE_TYPE (arg));
2531
2532   /* Try expanding via a sincos optab, fall back to emitting a libcall
2533      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2534      is only generated from sincos, cexp or if we have either of them.  */
2535   if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2536     {
2537       op1 = gen_reg_rtx (mode);
2538       op2 = gen_reg_rtx (mode);
2539
2540       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2541
2542       /* Compute into op1 and op2.  */
2543       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2544     }
2545   else if (TARGET_HAS_SINCOS)
2546     {
2547       tree call, fn = NULL_TREE;
2548       tree top1, top2;
2549       rtx op1a, op2a;
2550
2551       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2552         fn = built_in_decls[BUILT_IN_SINCOSF];
2553       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2554         fn = built_in_decls[BUILT_IN_SINCOS];
2555       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2556         fn = built_in_decls[BUILT_IN_SINCOSL];
2557       else
2558         gcc_unreachable ();
2559
2560       op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2561       op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2562       op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2563       op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2564       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2565       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2566
2567       /* Make sure not to fold the sincos call again.  */
2568       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2569       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2570                                       call, 3, arg, top1, top2));
2571     }
2572   else
2573     {
2574       tree call, fn = NULL_TREE, narg;
2575       tree ctype = build_complex_type (type);
2576
2577       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2578         fn = built_in_decls[BUILT_IN_CEXPF];
2579       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2580         fn = built_in_decls[BUILT_IN_CEXP];
2581       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2582         fn = built_in_decls[BUILT_IN_CEXPL];
2583       else
2584         gcc_unreachable ();
2585
2586       /* If we don't have a decl for cexp create one.  This is the
2587          friendliest fallback if the user calls __builtin_cexpi
2588          without full target C99 function support.  */
2589       if (fn == NULL_TREE)
2590         {
2591           tree fntype;
2592           const char *name = NULL;
2593
2594           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2595             name = "cexpf";
2596           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2597             name = "cexp";
2598           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2599             name = "cexpl";
2600
2601           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2602           fn = build_fn_decl (name, fntype);
2603         }
2604
2605       narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2606                           build_real (type, dconst0), arg);
2607
2608       /* Make sure not to fold the cexp call again.  */
2609       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2610       return expand_expr (build_call_nary (ctype, call, 1, narg),
2611                           target, VOIDmode, EXPAND_NORMAL);
2612     }
2613
2614   /* Now build the proper return type.  */
2615   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2616                               make_tree (TREE_TYPE (arg), op2),
2617                               make_tree (TREE_TYPE (arg), op1)),
2618                       target, VOIDmode, EXPAND_NORMAL);
2619 }
2620
2621 /* Conveniently construct a function call expression.  FNDECL names the
2622    function to be called, N is the number of arguments, and the "..."
2623    parameters are the argument expressions.  Unlike build_call_exr
2624    this doesn't fold the call, hence it will always return a CALL_EXPR.  */
2625
2626 static tree
2627 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2628 {
2629   va_list ap;
2630   tree fntype = TREE_TYPE (fndecl);
2631   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2632
2633   va_start (ap, n);
2634   fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2635   va_end (ap);
2636   SET_EXPR_LOCATION (fn, loc);
2637   return fn;
2638 }
2639
2640 /* Expand a call to one of the builtin rounding functions gcc defines
2641    as an extension (lfloor and lceil).  As these are gcc extensions we
2642    do not need to worry about setting errno to EDOM.
2643    If expanding via optab fails, lower expression to (int)(floor(x)).
2644    EXP is the expression that is a call to the builtin function;
2645    if convenient, the result should be placed in TARGET.  */
2646
2647 static rtx
2648 expand_builtin_int_roundingfn (tree exp, rtx target)
2649 {
2650   convert_optab builtin_optab;
2651   rtx op0, insns, tmp;
2652   tree fndecl = get_callee_fndecl (exp);
2653   enum built_in_function fallback_fn;
2654   tree fallback_fndecl;
2655   enum machine_mode mode;
2656   tree arg;
2657
2658   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2659     gcc_unreachable ();
2660
2661   arg = CALL_EXPR_ARG (exp, 0);
2662
2663   switch (DECL_FUNCTION_CODE (fndecl))
2664     {
2665     CASE_FLT_FN (BUILT_IN_LCEIL):
2666     CASE_FLT_FN (BUILT_IN_LLCEIL):
2667       builtin_optab = lceil_optab;
2668       fallback_fn = BUILT_IN_CEIL;
2669       break;
2670
2671     CASE_FLT_FN (BUILT_IN_LFLOOR):
2672     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2673       builtin_optab = lfloor_optab;
2674       fallback_fn = BUILT_IN_FLOOR;
2675       break;
2676
2677     default:
2678       gcc_unreachable ();
2679     }
2680
2681   /* Make a suitable register to place result in.  */
2682   mode = TYPE_MODE (TREE_TYPE (exp));
2683
2684   target = gen_reg_rtx (mode);
2685
2686   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2687      need to expand the argument again.  This way, we will not perform
2688      side-effects more the once.  */
2689   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2690
2691   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2692
2693   start_sequence ();
2694
2695   /* Compute into TARGET.  */
2696   if (expand_sfix_optab (target, op0, builtin_optab))
2697     {
2698       /* Output the entire sequence.  */
2699       insns = get_insns ();
2700       end_sequence ();
2701       emit_insn (insns);
2702       return target;
2703     }
2704
2705   /* If we were unable to expand via the builtin, stop the sequence
2706      (without outputting the insns).  */
2707   end_sequence ();
2708
2709   /* Fall back to floating point rounding optab.  */
2710   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2711
2712   /* For non-C99 targets we may end up without a fallback fndecl here
2713      if the user called __builtin_lfloor directly.  In this case emit
2714      a call to the floor/ceil variants nevertheless.  This should result
2715      in the best user experience for not full C99 targets.  */
2716   if (fallback_fndecl == NULL_TREE)
2717     {
2718       tree fntype;
2719       const char *name = NULL;
2720
2721       switch (DECL_FUNCTION_CODE (fndecl))
2722         {
2723         case BUILT_IN_LCEIL:
2724         case BUILT_IN_LLCEIL:
2725           name = "ceil";
2726           break;
2727         case BUILT_IN_LCEILF:
2728         case BUILT_IN_LLCEILF:
2729           name = "ceilf";
2730           break;
2731         case BUILT_IN_LCEILL:
2732         case BUILT_IN_LLCEILL:
2733           name = "ceill";
2734           break;
2735         case BUILT_IN_LFLOOR:
2736         case BUILT_IN_LLFLOOR:
2737           name = "floor";
2738           break;
2739         case BUILT_IN_LFLOORF:
2740         case BUILT_IN_LLFLOORF:
2741           name = "floorf";
2742           break;
2743         case BUILT_IN_LFLOORL:
2744         case BUILT_IN_LLFLOORL:
2745           name = "floorl";
2746           break;
2747         default:
2748           gcc_unreachable ();
2749         }
2750
2751       fntype = build_function_type_list (TREE_TYPE (arg),
2752                                          TREE_TYPE (arg), NULL_TREE);
2753       fallback_fndecl = build_fn_decl (name, fntype);
2754     }
2755
2756   exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2757
2758   tmp = expand_normal (exp);
2759
2760   /* Truncate the result of floating point optab to integer
2761      via expand_fix ().  */
2762   target = gen_reg_rtx (mode);
2763   expand_fix (target, tmp, 0);
2764
2765   return target;
2766 }
2767
2768 /* Expand a call to one of the builtin math functions doing integer
2769    conversion (lrint).
2770    Return 0 if a normal call should be emitted rather than expanding the
2771    function in-line.  EXP is the expression that is a call to the builtin
2772    function; if convenient, the result should be placed in TARGET.  */
2773
2774 static rtx
2775 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2776 {
2777   convert_optab builtin_optab;
2778   rtx op0, insns;
2779   tree fndecl = get_callee_fndecl (exp);
2780   tree arg;
2781   enum machine_mode mode;
2782
2783   /* There's no easy way to detect the case we need to set EDOM.  */
2784   if (flag_errno_math)
2785     return NULL_RTX;
2786
2787   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2788      gcc_unreachable ();
2789
2790   arg = CALL_EXPR_ARG (exp, 0);
2791
2792   switch (DECL_FUNCTION_CODE (fndecl))
2793     {
2794     CASE_FLT_FN (BUILT_IN_LRINT):
2795     CASE_FLT_FN (BUILT_IN_LLRINT):
2796       builtin_optab = lrint_optab; break;
2797     CASE_FLT_FN (BUILT_IN_LROUND):
2798     CASE_FLT_FN (BUILT_IN_LLROUND):
2799       builtin_optab = lround_optab; break;
2800     default:
2801       gcc_unreachable ();
2802     }
2803
2804   /* Make a suitable register to place result in.  */
2805   mode = TYPE_MODE (TREE_TYPE (exp));
2806
2807   target = gen_reg_rtx (mode);
2808
2809   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2810      need to expand the argument again.  This way, we will not perform
2811      side-effects more the once.  */
2812   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2813
2814   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2815
2816   start_sequence ();
2817
2818   if (expand_sfix_optab (target, op0, builtin_optab))
2819     {
2820       /* Output the entire sequence.  */
2821       insns = get_insns ();
2822       end_sequence ();
2823       emit_insn (insns);
2824       return target;
2825     }
2826
2827   /* If we were unable to expand via the builtin, stop the sequence
2828      (without outputting the insns) and call to the library function
2829      with the stabilized argument list.  */
2830   end_sequence ();
2831
2832   target = expand_call (exp, target, target == const0_rtx);
2833
2834   return target;
2835 }
2836
2837 /* To evaluate powi(x,n), the floating point value x raised to the
2838    constant integer exponent n, we use a hybrid algorithm that
2839    combines the "window method" with look-up tables.  For an
2840    introduction to exponentiation algorithms and "addition chains",
2841    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2842    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2843    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2844    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2845
2846 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2847    multiplications to inline before calling the system library's pow
2848    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2849    so this default never requires calling pow, powf or powl.  */
2850
2851 #ifndef POWI_MAX_MULTS
2852 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2853 #endif
2854
2855 /* The size of the "optimal power tree" lookup table.  All
2856    exponents less than this value are simply looked up in the
2857    powi_table below.  This threshold is also used to size the
2858    cache of pseudo registers that hold intermediate results.  */
2859 #define POWI_TABLE_SIZE 256
2860
2861 /* The size, in bits of the window, used in the "window method"
2862    exponentiation algorithm.  This is equivalent to a radix of
2863    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2864 #define POWI_WINDOW_SIZE 3
2865
2866 /* The following table is an efficient representation of an
2867    "optimal power tree".  For each value, i, the corresponding
2868    value, j, in the table states than an optimal evaluation
2869    sequence for calculating pow(x,i) can be found by evaluating
2870    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2871    100 integers is given in Knuth's "Seminumerical algorithms".  */
2872
2873 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2874   {
2875       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2876       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2877       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2878      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2879      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2880      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2881      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2882      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2883      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2884      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2885      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2886      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2887      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2888      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2889      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2890      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2891      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2892      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2893      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2894      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2895      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2896      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2897      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2898      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2899      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2900     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2901     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2902     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2903     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2904     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2905     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2906     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2907   };
2908
2909
2910 /* Return the number of multiplications required to calculate
2911    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2912    subroutine of powi_cost.  CACHE is an array indicating
2913    which exponents have already been calculated.  */
2914
2915 static int
2916 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2917 {
2918   /* If we've already calculated this exponent, then this evaluation
2919      doesn't require any additional multiplications.  */
2920   if (cache[n])
2921     return 0;
2922
2923   cache[n] = true;
2924   return powi_lookup_cost (n - powi_table[n], cache)
2925          + powi_lookup_cost (powi_table[n], cache) + 1;
2926 }
2927
2928 /* Return the number of multiplications required to calculate
2929    powi(x,n) for an arbitrary x, given the exponent N.  This
2930    function needs to be kept in sync with expand_powi below.  */
2931
2932 static int
2933 powi_cost (HOST_WIDE_INT n)
2934 {
2935   bool cache[POWI_TABLE_SIZE];
2936   unsigned HOST_WIDE_INT digit;
2937   unsigned HOST_WIDE_INT val;
2938   int result;
2939
2940   if (n == 0)
2941     return 0;
2942
2943   /* Ignore the reciprocal when calculating the cost.  */
2944   val = (n < 0) ? -n : n;
2945
2946   /* Initialize the exponent cache.  */
2947   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2948   cache[1] = true;
2949
2950   result = 0;
2951
2952   while (val >= POWI_TABLE_SIZE)
2953     {
2954       if (val & 1)
2955         {
2956           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2957           result += powi_lookup_cost (digit, cache)
2958                     + POWI_WINDOW_SIZE + 1;
2959           val >>= POWI_WINDOW_SIZE;
2960         }
2961       else
2962         {
2963           val >>= 1;
2964           result++;
2965         }
2966     }
2967
2968   return result + powi_lookup_cost (val, cache);
2969 }
2970
2971 /* Recursive subroutine of expand_powi.  This function takes the array,
2972    CACHE, of already calculated exponents and an exponent N and returns
2973    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2974
2975 static rtx
2976 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2977 {
2978   unsigned HOST_WIDE_INT digit;
2979   rtx target, result;
2980   rtx op0, op1;
2981
2982   if (n < POWI_TABLE_SIZE)
2983     {
2984       if (cache[n])
2985         return cache[n];
2986
2987       target = gen_reg_rtx (mode);
2988       cache[n] = target;
2989
2990       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2991       op1 = expand_powi_1 (mode, powi_table[n], cache);
2992     }
2993   else if (n & 1)
2994     {
2995       target = gen_reg_rtx (mode);
2996       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2997       op0 = expand_powi_1 (mode, n - digit, cache);
2998       op1 = expand_powi_1 (mode, digit, cache);
2999     }
3000   else
3001     {
3002       target = gen_reg_rtx (mode);
3003       op0 = expand_powi_1 (mode, n >> 1, cache);
3004       op1 = op0;
3005     }
3006
3007   result = expand_mult (mode, op0, op1, target, 0);
3008   if (result != target)
3009     emit_move_insn (target, result);
3010   return target;
3011 }
3012
3013 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
3014    floating point operand in mode MODE, and N is the exponent.  This
3015    function needs to be kept in sync with powi_cost above.  */
3016
3017 static rtx
3018 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
3019 {
3020   rtx cache[POWI_TABLE_SIZE];
3021   rtx result;
3022
3023   if (n == 0)
3024     return CONST1_RTX (mode);
3025
3026   memset (cache, 0, sizeof (cache));
3027   cache[1] = x;
3028
3029   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
3030
3031   /* If the original exponent was negative, reciprocate the result.  */
3032   if (n < 0)
3033     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3034                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3035
3036   return result;
3037 }
3038
3039 /* Fold a builtin function call to pow, powf, or powl into a series of sqrts or
3040    cbrts.  Return NULL_RTX if no simplification can be made or expand the tree
3041    if we can simplify it.  */
3042 static rtx
3043 expand_builtin_pow_root (location_t loc, tree arg0, tree arg1, tree type,
3044                          rtx subtarget)
3045 {
3046   if (TREE_CODE (arg1) == REAL_CST
3047       && !TREE_OVERFLOW (arg1)
3048       && flag_unsafe_math_optimizations)
3049     {
3050       enum machine_mode mode = TYPE_MODE (type);
3051       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
3052       tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
3053       REAL_VALUE_TYPE c = TREE_REAL_CST (arg1);
3054       tree op = NULL_TREE;
3055
3056       if (sqrtfn)
3057         {
3058           /* Optimize pow (x, 0.5) into sqrt.  */
3059           if (REAL_VALUES_EQUAL (c, dconsthalf))
3060             op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3061
3062           /* Don't do this optimization if we don't have a sqrt insn.  */
3063           else if (optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)
3064             {
3065               REAL_VALUE_TYPE dconst1_4 = dconst1;
3066               REAL_VALUE_TYPE dconst3_4;
3067               SET_REAL_EXP (&dconst1_4, REAL_EXP (&dconst1_4) - 2);
3068
3069               real_from_integer (&dconst3_4, VOIDmode, 3, 0, 0);
3070               SET_REAL_EXP (&dconst3_4, REAL_EXP (&dconst3_4) - 2);
3071
3072               /* Optimize pow (x, 0.25) into sqrt (sqrt (x)).  Assume on most
3073                  machines that a builtin sqrt instruction is smaller than a
3074                  call to pow with 0.25, so do this optimization even if
3075                  -Os.  */
3076               if (REAL_VALUES_EQUAL (c, dconst1_4))
3077                 {
3078                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3079                   op = build_call_nofold_loc (loc, sqrtfn, 1, op);
3080                 }
3081
3082               /* Optimize pow (x, 0.75) = sqrt (x) * sqrt (sqrt (x)) unless we
3083                  are optimizing for space.  */
3084               else if (optimize_insn_for_speed_p ()
3085                        && !TREE_SIDE_EFFECTS (arg0)
3086                        && REAL_VALUES_EQUAL (c, dconst3_4))
3087                 {
3088                   tree sqrt1 = build_call_expr_loc (loc, sqrtfn, 1, arg0);
3089                   tree sqrt2 = builtin_save_expr (sqrt1);
3090                   tree sqrt3 = build_call_expr_loc (loc, sqrtfn, 1, sqrt1);
3091                   op = fold_build2_loc (loc, MULT_EXPR, type, sqrt2, sqrt3);
3092                 }
3093             }
3094         }
3095
3096       /* Check whether we can do cbrt insstead of pow (x, 1./3.) and
3097          cbrt/sqrts instead of pow (x, 1./6.).  */
3098       if (cbrtfn && ! op
3099           && (tree_expr_nonnegative_p (arg0) || !HONOR_NANS (mode)))
3100         {
3101           /* First try 1/3.  */
3102           REAL_VALUE_TYPE dconst1_3
3103             = real_value_truncate (mode, dconst_third ());
3104
3105           if (REAL_VALUES_EQUAL (c, dconst1_3))
3106             op = build_call_nofold_loc (loc, cbrtfn, 1, arg0);
3107
3108               /* Now try 1/6.  */
3109           else if (optimize_insn_for_speed_p ()
3110                    && optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)
3111             {
3112               REAL_VALUE_TYPE dconst1_6 = dconst1_3;
3113               SET_REAL_EXP (&dconst1_6, REAL_EXP (&dconst1_6) - 1);
3114
3115               if (REAL_VALUES_EQUAL (c, dconst1_6))
3116                 {
3117                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3118                   op = build_call_nofold_loc (loc, cbrtfn, 1, op);
3119                 }
3120             }
3121         }
3122
3123       if (op)
3124         return expand_expr (op, subtarget, mode, EXPAND_NORMAL);
3125     }
3126
3127   return NULL_RTX;
3128 }
3129
3130 /* Expand a call to the pow built-in mathematical function.  Return NULL_RTX if
3131    a normal call should be emitted rather than expanding the function
3132    in-line.  EXP is the expression that is a call to the builtin
3133    function; if convenient, the result should be placed in TARGET.  */
3134
3135 static rtx
3136 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
3137 {
3138   tree arg0, arg1;
3139   tree fn, narg0;
3140   tree type = TREE_TYPE (exp);
3141   REAL_VALUE_TYPE cint, c, c2;
3142   HOST_WIDE_INT n;
3143   rtx op, op2;
3144   enum machine_mode mode = TYPE_MODE (type);
3145
3146   if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
3147     return NULL_RTX;
3148
3149   arg0 = CALL_EXPR_ARG (exp, 0);
3150   arg1 = CALL_EXPR_ARG (exp, 1);
3151
3152   if (TREE_CODE (arg1) != REAL_CST
3153       || TREE_OVERFLOW (arg1))
3154     return expand_builtin_mathfn_2 (exp, target, subtarget);
3155
3156   /* Handle constant exponents.  */
3157
3158   /* For integer valued exponents we can expand to an optimal multiplication
3159      sequence using expand_powi.  */
3160   c = TREE_REAL_CST (arg1);
3161   n = real_to_integer (&c);
3162   real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3163   if (real_identical (&c, &cint)
3164       && ((n >= -1 && n <= 2)
3165           || (flag_unsafe_math_optimizations
3166               && optimize_insn_for_speed_p ()
3167               && powi_cost (n) <= POWI_MAX_MULTS)))
3168     {
3169       op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3170       if (n != 1)
3171         {
3172           op = force_reg (mode, op);
3173           op = expand_powi (op, mode, n);
3174         }
3175       return op;
3176     }
3177
3178   narg0 = builtin_save_expr (arg0);
3179
3180   /* If the exponent is not integer valued, check if it is half of an integer.
3181      In this case we can expand to sqrt (x) * x**(n/2).  */
3182   fn = mathfn_built_in (type, BUILT_IN_SQRT);
3183   if (fn != NULL_TREE)
3184     {
3185       real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
3186       n = real_to_integer (&c2);
3187       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3188       if (real_identical (&c2, &cint)
3189           && ((flag_unsafe_math_optimizations
3190                && optimize_insn_for_speed_p ()
3191                && powi_cost (n/2) <= POWI_MAX_MULTS)
3192               /* Even the c == 0.5 case cannot be done unconditionally
3193                  when we need to preserve signed zeros, as
3194                  pow (-0, 0.5) is +0, while sqrt(-0) is -0.  */
3195               || (!HONOR_SIGNED_ZEROS (mode) && n == 1)
3196               /* For c == 1.5 we can assume that x * sqrt (x) is always
3197                  smaller than pow (x, 1.5) if sqrt will not be expanded
3198                  as a call.  */
3199               || (n == 3
3200                   && optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)))
3201         {
3202           tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3203                                                   narg0);
3204           /* Use expand_expr in case the newly built call expression
3205              was folded to a non-call.  */
3206           op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
3207           if (n != 1)
3208             {
3209               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3210               op2 = force_reg (mode, op2);
3211               op2 = expand_powi (op2, mode, abs (n / 2));
3212               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3213                                         0, OPTAB_LIB_WIDEN);
3214               /* If the original exponent was negative, reciprocate the
3215                  result.  */
3216               if (n < 0)
3217                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3218                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3219             }
3220           return op;
3221         }
3222     }
3223
3224   /* Check whether we can do a series of sqrt or cbrt's instead of the pow
3225      call.  */
3226   op = expand_builtin_pow_root (EXPR_LOCATION (exp), arg0, arg1, type,
3227                                 subtarget);
3228   if (op)
3229     return op;
3230
3231   /* Try if the exponent is a third of an integer.  In this case
3232      we can expand to x**(n/3) * cbrt(x)**(n%3).  As cbrt (x) is
3233      different from pow (x, 1./3.) due to rounding and behavior
3234      with negative x we need to constrain this transformation to
3235      unsafe math and positive x or finite math.  */
3236   fn = mathfn_built_in (type, BUILT_IN_CBRT);
3237   if (fn != NULL_TREE
3238       && flag_unsafe_math_optimizations
3239       && (tree_expr_nonnegative_p (arg0)
3240           || !HONOR_NANS (mode)))
3241     {
3242       REAL_VALUE_TYPE dconst3;
3243       real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3244       real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3245       real_round (&c2, mode, &c2);
3246       n = real_to_integer (&c2);
3247       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3248       real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3249       real_convert (&c2, mode, &c2);
3250       if (real_identical (&c2, &c)
3251           && ((optimize_insn_for_speed_p ()
3252                && powi_cost (n/3) <= POWI_MAX_MULTS)
3253               || n == 1))
3254         {
3255           tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3256                                                   narg0);
3257           op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3258           if (abs (n) % 3 == 2)
3259             op = expand_simple_binop (mode, MULT, op, op, op,
3260                                       0, OPTAB_LIB_WIDEN);
3261           if (n != 1)
3262             {
3263               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3264               op2 = force_reg (mode, op2);
3265               op2 = expand_powi (op2, mode, abs (n / 3));
3266               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3267                                         0, OPTAB_LIB_WIDEN);
3268               /* If the original exponent was negative, reciprocate the
3269                  result.  */
3270               if (n < 0)
3271                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3272                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3273             }
3274           return op;
3275         }
3276     }
3277
3278   /* Fall back to optab expansion.  */
3279   return expand_builtin_mathfn_2 (exp, target, subtarget);
3280 }
3281
3282 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
3283    a normal call should be emitted rather than expanding the function
3284    in-line.  EXP is the expression that is a call to the builtin
3285    function; if convenient, the result should be placed in TARGET.  */
3286
3287 static rtx
3288 expand_builtin_powi (tree exp, rtx target)
3289 {
3290   tree arg0, arg1;
3291   rtx op0, op1;
3292   enum machine_mode mode;
3293   enum machine_mode mode2;
3294
3295   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3296     return NULL_RTX;
3297
3298   arg0 = CALL_EXPR_ARG (exp, 0);
3299   arg1 = CALL_EXPR_ARG (exp, 1);
3300   mode = TYPE_MODE (TREE_TYPE (exp));
3301
3302   /* Handle constant power.  */
3303
3304   if (TREE_CODE (arg1) == INTEGER_CST
3305       && !TREE_OVERFLOW (arg1))
3306     {
3307       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3308
3309       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3310          Otherwise, check the number of multiplications required.  */
3311       if ((TREE_INT_CST_HIGH (arg1) == 0
3312            || TREE_INT_CST_HIGH (arg1) == -1)
3313           && ((n >= -1 && n <= 2)
3314               || (optimize_insn_for_speed_p ()
3315                   && powi_cost (n) <= POWI_MAX_MULTS)))
3316         {
3317           op0 = expand_expr (arg0, NULL_RTX, VOIDmode, EXPAND_NORMAL);
3318           op0 = force_reg (mode, op0);
3319           return expand_powi (op0, mode, n);
3320         }
3321     }
3322
3323   /* Emit a libcall to libgcc.  */
3324
3325   /* Mode of the 2nd argument must match that of an int.  */
3326   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3327
3328   if (target == NULL_RTX)
3329     target = gen_reg_rtx (mode);
3330
3331   op0 = expand_expr (arg0, NULL_RTX, mode, EXPAND_NORMAL);
3332   if (GET_MODE (op0) != mode)
3333     op0 = convert_to_mode (mode, op0, 0);
3334   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3335   if (GET_MODE (op1) != mode2)
3336     op1 = convert_to_mode (mode2, op1, 0);
3337
3338   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3339                                     target, LCT_CONST, mode, 2,
3340                                     op0, mode, op1, mode2);
3341
3342   return target;
3343 }
3344
3345 /* Expand expression EXP which is a call to the strlen builtin.  Return
3346    NULL_RTX if we failed the caller should emit a normal call, otherwise
3347    try to get the result in TARGET, if convenient.  */
3348
3349 static rtx
3350 expand_builtin_strlen (tree exp, rtx target,
3351                        enum machine_mode target_mode)
3352 {
3353   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3354     return NULL_RTX;
3355   else
3356     {
3357       struct expand_operand ops[4];
3358       rtx pat;
3359       tree len;
3360       tree src = CALL_EXPR_ARG (exp, 0);
3361       rtx src_reg, before_strlen;
3362       enum machine_mode insn_mode = target_mode;
3363       enum insn_code icode = CODE_FOR_nothing;
3364       unsigned int align;
3365
3366       /* If the length can be computed at compile-time, return it.  */
3367       len = c_strlen (src, 0);
3368       if (len)
3369         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3370
3371       /* If the length can be computed at compile-time and is constant
3372          integer, but there are side-effects in src, evaluate
3373          src for side-effects, then return len.
3374          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3375          can be optimized into: i++; x = 3;  */
3376       len = c_strlen (src, 1);
3377       if (len && TREE_CODE (len) == INTEGER_CST)
3378         {
3379           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3380           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3381         }
3382
3383       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3384
3385       /* If SRC is not a pointer type, don't do this operation inline.  */
3386       if (align == 0)
3387         return NULL_RTX;
3388
3389       /* Bail out if we can't compute strlen in the right mode.  */
3390       while (insn_mode != VOIDmode)
3391         {
3392           icode = optab_handler (strlen_optab, insn_mode);
3393           if (icode != CODE_FOR_nothing)
3394             break;
3395
3396           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3397         }
3398       if (insn_mode == VOIDmode)
3399         return NULL_RTX;
3400
3401       /* Make a place to hold the source address.  We will not expand
3402          the actual source until we are sure that the expansion will
3403          not fail -- there are trees that cannot be expanded twice.  */
3404       src_reg = gen_reg_rtx (Pmode);
3405
3406       /* Mark the beginning of the strlen sequence so we can emit the
3407          source operand later.  */
3408       before_strlen = get_last_insn ();
3409
3410       create_output_operand (&ops[0], target, insn_mode);
3411       create_fixed_operand (&ops[1], gen_rtx_MEM (BLKmode, src_reg));
3412       create_integer_operand (&ops[2], 0);
3413       create_integer_operand (&ops[3], align);
3414       if (!maybe_expand_insn (icode, 4, ops))
3415         return NULL_RTX;
3416
3417       /* Now that we are assured of success, expand the source.  */
3418       start_sequence ();
3419       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3420       if (pat != src_reg)
3421         emit_move_insn (src_reg, pat);
3422       pat = get_insns ();
3423       end_sequence ();
3424
3425       if (before_strlen)
3426         emit_insn_after (pat, before_strlen);
3427       else
3428         emit_insn_before (pat, get_insns ());
3429
3430       /* Return the value in the proper mode for this function.  */
3431       if (GET_MODE (ops[0].value) == target_mode)
3432         target = ops[0].value;
3433       else if (target != 0)
3434         convert_move (target, ops[0].value, 0);
3435       else
3436         target = convert_to_mode (target_mode, ops[0].value, 0);
3437
3438       return target;
3439     }
3440 }
3441
3442 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3443    bytes from constant string DATA + OFFSET and return it as target
3444    constant.  */
3445
3446 static rtx
3447 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3448                          enum machine_mode mode)
3449 {
3450   const char *str = (const char *) data;
3451
3452   gcc_assert (offset >= 0
3453               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3454                   <= strlen (str) + 1));
3455
3456   return c_readstr (str + offset, mode);
3457 }
3458
3459 /* Expand a call EXP to the memcpy builtin.
3460    Return NULL_RTX if we failed, the caller should emit a normal call,
3461    otherwise try to get the result in TARGET, if convenient (and in
3462    mode MODE if that's convenient).  */
3463
3464 static rtx
3465 expand_builtin_memcpy (tree exp, rtx target)
3466 {
3467   if (!validate_arglist (exp,
3468                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3469     return NULL_RTX;
3470   else
3471     {
3472       tree dest = CALL_EXPR_ARG (exp, 0);
3473       tree src = CALL_EXPR_ARG (exp, 1);
3474       tree len = CALL_EXPR_ARG (exp, 2);
3475       const char *src_str;
3476       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3477       unsigned int dest_align
3478         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3479       rtx dest_mem, src_mem, dest_addr, len_rtx;
3480       HOST_WIDE_INT expected_size = -1;
3481       unsigned int expected_align = 0;
3482
3483       /* If DEST is not a pointer type, call the normal function.  */
3484       if (dest_align == 0)
3485         return NULL_RTX;
3486
3487       /* If either SRC is not a pointer type, don't do this
3488          operation in-line.  */
3489       if (src_align == 0)
3490         return NULL_RTX;
3491
3492       if (currently_expanding_gimple_stmt)
3493         stringop_block_profile (currently_expanding_gimple_stmt,
3494                                 &expected_align, &expected_size);
3495
3496       if (expected_align < dest_align)
3497         expected_align = dest_align;
3498       dest_mem = get_memory_rtx (dest, len);
3499       set_mem_align (dest_mem, dest_align);
3500       len_rtx = expand_normal (len);
3501       src_str = c_getstr (src);
3502
3503       /* If SRC is a string constant and block move would be done
3504          by pieces, we can avoid loading the string from memory
3505          and only stored the computed constants.  */
3506       if (src_str
3507           && CONST_INT_P (len_rtx)
3508           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3509           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3510                                   CONST_CAST (char *, src_str),
3511                                   dest_align, false))
3512         {
3513           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3514                                       builtin_memcpy_read_str,
3515                                       CONST_CAST (char *, src_str),
3516                                       dest_align, false, 0);
3517           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3518           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3519           return dest_mem;
3520         }
3521
3522       src_mem = get_memory_rtx (src, len);
3523       set_mem_align (src_mem, src_align);
3524
3525       /* Copy word part most expediently.  */
3526       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3527                                          CALL_EXPR_TAILCALL (exp)
3528                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3529                                          expected_align, expected_size);
3530
3531       if (dest_addr == 0)
3532         {
3533           dest_addr = force_operand (XEXP (dest_mem, 0), target);
3534           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3535         }
3536       return dest_addr;
3537     }
3538 }
3539
3540 /* Expand a call EXP to the mempcpy builtin.
3541    Return NULL_RTX if we failed; the caller should emit a normal call,
3542    otherwise try to get the result in TARGET, if convenient (and in
3543    mode MODE if that's convenient).  If ENDP is 0 return the
3544    destination pointer, if ENDP is 1 return the end pointer ala
3545    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3546    stpcpy.  */
3547
3548 static rtx
3549 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3550 {
3551   if (!validate_arglist (exp,
3552                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3553     return NULL_RTX;
3554   else
3555     {
3556       tree dest = CALL_EXPR_ARG (exp, 0);
3557       tree src = CALL_EXPR_ARG (exp, 1);
3558       tree len = CALL_EXPR_ARG (exp, 2);
3559       return expand_builtin_mempcpy_args (dest, src, len,
3560                                           target, mode, /*endp=*/ 1);
3561     }
3562 }
3563
3564 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3565    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3566    so that this can also be called without constructing an actual CALL_EXPR.
3567    The other arguments and return value are the same as for
3568    expand_builtin_mempcpy.  */
3569
3570 static rtx
3571 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3572                              rtx target, enum machine_mode mode, int endp)
3573 {
3574     /* If return value is ignored, transform mempcpy into memcpy.  */
3575   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3576     {
3577       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3578       tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3579                                            dest, src, len);
3580       return expand_expr (result, target, mode, EXPAND_NORMAL);
3581     }
3582   else
3583     {
3584       const char *src_str;
3585       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3586       unsigned int dest_align
3587         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3588       rtx dest_mem, src_mem, len_rtx;
3589
3590       /* If either SRC or DEST is not a pointer type, don't do this
3591          operation in-line.  */
3592       if (dest_align == 0 || src_align == 0)
3593         return NULL_RTX;
3594
3595       /* If LEN is not constant, call the normal function.  */
3596       if (! host_integerp (len, 1))
3597         return NULL_RTX;
3598
3599       len_rtx = expand_normal (len);
3600       src_str = c_getstr (src);
3601
3602       /* If SRC is a string constant and block move would be done
3603          by pieces, we can avoid loading the string from memory
3604          and only stored the computed constants.  */
3605       if (src_str
3606           && CONST_INT_P (len_rtx)
3607           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3608           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3609                                   CONST_CAST (char *, src_str),
3610                                   dest_align, false))
3611         {
3612           dest_mem = get_memory_rtx (dest, len);
3613           set_mem_align (dest_mem, dest_align);
3614           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3615                                       builtin_memcpy_read_str,
3616                                       CONST_CAST (char *, src_str),
3617                                       dest_align, false, endp);
3618           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3619           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3620           return dest_mem;
3621         }
3622
3623       if (CONST_INT_P (len_rtx)
3624           && can_move_by_pieces (INTVAL (len_rtx),
3625                                  MIN (dest_align, src_align)))
3626         {
3627           dest_mem = get_memory_rtx (dest, len);
3628           set_mem_align (dest_mem, dest_align);
3629           src_mem = get_memory_rtx (src, len);
3630           set_mem_align (src_mem, src_align);
3631           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3632                                      MIN (dest_align, src_align), endp);
3633           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3634           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3635           return dest_mem;
3636         }
3637
3638       return NULL_RTX;
3639     }
3640 }
3641
3642 #ifndef HAVE_movstr
3643 # define HAVE_movstr 0
3644 # define CODE_FOR_movstr CODE_FOR_nothing
3645 #endif
3646
3647 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3648    we failed, the caller should emit a normal call, otherwise try to
3649    get the result in TARGET, if convenient.  If ENDP is 0 return the
3650    destination pointer, if ENDP is 1 return the end pointer ala
3651    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3652    stpcpy.  */
3653
3654 static rtx
3655 expand_movstr (tree dest, tree src, rtx target, int endp)
3656 {
3657   struct expand_operand ops[3];
3658   rtx dest_mem;
3659   rtx src_mem;
3660
3661   if (!HAVE_movstr)
3662     return NULL_RTX;
3663
3664   dest_mem = get_memory_rtx (dest, NULL);
3665   src_mem = get_memory_rtx (src, NULL);
3666   if (!endp)
3667     {
3668       target = force_reg (Pmode, XEXP (dest_mem, 0));
3669       dest_mem = replace_equiv_address (dest_mem, target);
3670     }
3671
3672   create_output_operand (&ops[0], endp ? target : NULL_RTX, Pmode);
3673   create_fixed_operand (&ops[1], dest_mem);
3674   create_fixed_operand (&ops[2], src_mem);
3675   expand_insn (CODE_FOR_movstr, 3, ops);
3676
3677   if (endp && target != const0_rtx)
3678     {
3679       target = ops[0].value;
3680       /* movstr is supposed to set end to the address of the NUL
3681          terminator.  If the caller requested a mempcpy-like return value,
3682          adjust it.  */
3683       if (endp == 1)
3684         {
3685           rtx tem = plus_constant (gen_lowpart (GET_MODE (target), target), 1);
3686           emit_move_insn (target, force_operand (tem, NULL_RTX));
3687         }
3688     }
3689   return target;
3690 }
3691
3692 /* Expand expression EXP, which is a call to the strcpy builtin.  Return
3693    NULL_RTX if we failed the caller should emit a normal call, otherwise
3694    try to get the result in TARGET, if convenient (and in mode MODE if that's
3695    convenient).  */
3696
3697 static rtx
3698 expand_builtin_strcpy (tree exp, rtx target)
3699 {
3700   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3701    {
3702      tree dest = CALL_EXPR_ARG (exp, 0);
3703      tree src = CALL_EXPR_ARG (exp, 1);
3704      return expand_builtin_strcpy_args (dest, src, target);
3705    }
3706    return NULL_RTX;
3707 }
3708
3709 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3710    arguments to the builtin_strcpy call DEST and SRC are broken out
3711    so that this can also be called without constructing an actual CALL_EXPR.
3712    The other arguments and return value are the same as for
3713    expand_builtin_strcpy.  */
3714
3715 static rtx
3716 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3717 {
3718   return expand_movstr (dest, src, target, /*endp=*/0);
3719 }
3720
3721 /* Expand a call EXP to the stpcpy builtin.
3722    Return NULL_RTX if we failed the caller should emit a normal call,
3723    otherwise try to get the result in TARGET, if convenient (and in
3724    mode MODE if that's convenient).  */
3725
3726 static rtx
3727 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3728 {
3729   tree dst, src;
3730   location_t loc = EXPR_LOCATION (exp);
3731
3732   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3733     return NULL_RTX;
3734
3735   dst = CALL_EXPR_ARG (exp, 0);
3736   src = CALL_EXPR_ARG (exp, 1);
3737
3738   /* If return value is ignored, transform stpcpy into strcpy.  */
3739   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3740     {
3741       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3742       tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3743       return expand_expr (result, target, mode, EXPAND_NORMAL);
3744     }
3745   else
3746     {
3747       tree len, lenp1;
3748       rtx ret;
3749
3750       /* Ensure we get an actual string whose length can be evaluated at
3751          compile-time, not an expression containing a string.  This is
3752          because the latter will potentially produce pessimized code
3753          when used to produce the return value.  */
3754       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3755         return expand_movstr (dst, src, target, /*endp=*/2);
3756
3757       lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3758       ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3759                                          target, mode, /*endp=*/2);
3760
3761       if (ret)
3762         return ret;
3763
3764       if (TREE_CODE (len) == INTEGER_CST)
3765         {
3766           rtx len_rtx = expand_normal (len);
3767
3768           if (CONST_INT_P (len_rtx))
3769             {
3770               ret = expand_builtin_strcpy_args (dst, src, target);
3771
3772               if (ret)
3773                 {
3774                   if (! target)
3775                     {
3776                       if (mode != VOIDmode)
3777                         target = gen_reg_rtx (mode);
3778                       else
3779                         target = gen_reg_rtx (GET_MODE (ret));
3780                     }
3781                   if (GET_MODE (target) != GET_MODE (ret))
3782                     ret = gen_lowpart (GET_MODE (target), ret);
3783
3784                   ret = plus_constant (ret, INTVAL (len_rtx));
3785                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3786                   gcc_assert (ret);
3787
3788                   return target;
3789                 }
3790             }
3791         }
3792
3793       return expand_movstr (dst, src, target, /*endp=*/2);
3794     }
3795 }
3796
3797 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3798    bytes from constant string DATA + OFFSET and return it as target
3799    constant.  */
3800
3801 rtx
3802 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3803                           enum machine_mode mode)
3804 {
3805   const char *str = (const char *) data;
3806
3807   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3808     return const0_rtx;
3809
3810   return c_readstr (str + offset, mode);
3811 }
3812
3813 /* Expand expression EXP, which is a call to the strncpy builtin.  Return
3814    NULL_RTX if we failed the caller should emit a normal call.  */
3815
3816 static rtx
3817 expand_builtin_strncpy (tree exp, rtx target)
3818 {
3819   location_t loc = EXPR_LOCATION (exp);
3820
3821   if (validate_arglist (exp,
3822                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3823     {
3824       tree dest = CALL_EXPR_ARG (exp, 0);
3825       tree src = CALL_EXPR_ARG (exp, 1);
3826       tree len = CALL_EXPR_ARG (exp, 2);
3827       tree slen = c_strlen (src, 1);
3828
3829       /* We must be passed a constant len and src parameter.  */
3830       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3831         return NULL_RTX;
3832
3833       slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3834
3835       /* We're required to pad with trailing zeros if the requested
3836          len is greater than strlen(s2)+1.  In that case try to
3837          use store_by_pieces, if it fails, punt.  */
3838       if (tree_int_cst_lt (slen, len))
3839         {
3840           unsigned int dest_align
3841             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3842           const char *p = c_getstr (src);
3843           rtx dest_mem;
3844
3845           if (!p || dest_align == 0 || !host_integerp (len, 1)
3846               || !can_store_by_pieces (tree_low_cst (len, 1),
3847                                        builtin_strncpy_read_str,
3848                                        CONST_CAST (char *, p),
3849                                        dest_align, false))
3850             return NULL_RTX;
3851
3852           dest_mem = get_memory_rtx (dest, len);
3853           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3854                            builtin_strncpy_read_str,
3855                            CONST_CAST (char *, p), dest_align, false, 0);
3856           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3857           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3858           return dest_mem;
3859         }
3860     }
3861   return NULL_RTX;
3862 }
3863
3864 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3865    bytes from constant string DATA + OFFSET and return it as target
3866    constant.  */
3867
3868 rtx
3869 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3870                          enum machine_mode mode)
3871 {
3872   const char *c = (const char *) data;
3873   char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3874
3875   memset (p, *c, GET_MODE_SIZE (mode));
3876
3877   return c_readstr (p, mode);
3878 }
3879
3880 /* Callback routine for store_by_pieces.  Return the RTL of a register
3881    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3882    char value given in the RTL register data.  For example, if mode is
3883    4 bytes wide, return the RTL for 0x01010101*data.  */
3884
3885 static rtx
3886 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3887                         enum machine_mode mode)
3888 {
3889   rtx target, coeff;
3890   size_t size;
3891   char *p;
3892
3893   size = GET_MODE_SIZE (mode);
3894   if (size == 1)
3895     return (rtx) data;
3896
3897   p = XALLOCAVEC (char, size);
3898   memset (p, 1, size);
3899   coeff = c_readstr (p, mode);
3900
3901   target = convert_to_mode (mode, (rtx) data, 1);
3902   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3903   return force_reg (mode, target);
3904 }
3905
3906 /* Expand expression EXP, which is a call to the memset builtin.  Return
3907    NULL_RTX if we failed the caller should emit a normal call, otherwise
3908    try to get the result in TARGET, if convenient (and in mode MODE if that's
3909    convenient).  */
3910
3911 static rtx
3912 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3913 {
3914   if (!validate_arglist (exp,
3915                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3916     return NULL_RTX;
3917   else
3918     {
3919       tree dest = CALL_EXPR_ARG (exp, 0);
3920       tree val = CALL_EXPR_ARG (exp, 1);
3921       tree len = CALL_EXPR_ARG (exp, 2);
3922       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3923     }
3924 }
3925
3926 /* Helper function to do the actual work for expand_builtin_memset.  The
3927    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3928    so that this can also be called without constructing an actual CALL_EXPR.
3929    The other arguments and return value are the same as for
3930    expand_builtin_memset.  */
3931
3932 static rtx
3933 expand_builtin_memset_args (tree dest, tree val, tree len,
3934                             rtx target, enum machine_mode mode, tree orig_exp)
3935 {
3936   tree fndecl, fn;
3937   enum built_in_function fcode;
3938   char c;
3939   unsigned int dest_align;
3940   rtx dest_mem, dest_addr, len_rtx;
3941   HOST_WIDE_INT expected_size = -1;
3942   unsigned int expected_align = 0;
3943
3944   dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3945
3946   /* If DEST is not a pointer type, don't do this operation in-line.  */
3947   if (dest_align == 0)
3948     return NULL_RTX;
3949
3950   if (currently_expanding_gimple_stmt)
3951     stringop_block_profile (currently_expanding_gimple_stmt,
3952                             &expected_align, &expected_size);
3953
3954   if (expected_align < dest_align)
3955     expected_align = dest_align;
3956
3957   /* If the LEN parameter is zero, return DEST.  */
3958   if (integer_zerop (len))
3959     {
3960       /* Evaluate and ignore VAL in case it has side-effects.  */
3961       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3962       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3963     }
3964
3965   /* Stabilize the arguments in case we fail.  */
3966   dest = builtin_save_expr (dest);
3967   val = builtin_save_expr (val);
3968   len = builtin_save_expr (len);
3969
3970   len_rtx = expand_normal (len);
3971   dest_mem = get_memory_rtx (dest, len);
3972
3973   if (TREE_CODE (val) != INTEGER_CST)
3974     {
3975       rtx val_rtx;
3976
3977       val_rtx = expand_normal (val);
3978       val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3979                                  val_rtx, 0);
3980
3981       /* Assume that we can memset by pieces if we can store
3982        * the coefficients by pieces (in the required modes).
3983        * We can't pass builtin_memset_gen_str as that emits RTL.  */
3984       c = 1;
3985       if (host_integerp (len, 1)
3986           && can_store_by_pieces (tree_low_cst (len, 1),
3987                                   builtin_memset_read_str, &c, dest_align,
3988                                   true))
3989         {
3990           val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3991                                val_rtx);
3992           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3993                            builtin_memset_gen_str, val_rtx, dest_align,
3994                            true, 0);
3995         }
3996       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
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   if (target_char_cast (val, &c))
4007     goto do_libcall;
4008
4009   if (c)
4010     {
4011       if (host_integerp (len, 1)
4012           && can_store_by_pieces (tree_low_cst (len, 1),
4013                                   builtin_memset_read_str, &c, dest_align,
4014                                   true))
4015         store_by_pieces (dest_mem, tree_low_cst (len, 1),
4016                          builtin_memset_read_str, &c, dest_align, true, 0);
4017       else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
4018                                         dest_align, expected_align,
4019                                         expected_size))
4020         goto do_libcall;
4021
4022       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4023       dest_mem = convert_memory_address (ptr_mode, dest_mem);
4024       return dest_mem;
4025     }
4026
4027   set_mem_align (dest_mem, dest_align);
4028   dest_addr = clear_storage_hints (dest_mem, len_rtx,
4029                                    CALL_EXPR_TAILCALL (orig_exp)
4030                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
4031                                    expected_align, expected_size);
4032
4033   if (dest_addr == 0)
4034     {
4035       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4036       dest_addr = convert_memory_address (ptr_mode, dest_addr);
4037     }
4038
4039   return dest_addr;
4040
4041  do_libcall:
4042   fndecl = get_callee_fndecl (orig_exp);
4043   fcode = DECL_FUNCTION_CODE (fndecl);
4044   if (fcode == BUILT_IN_MEMSET)
4045     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
4046                                 dest, val, len);
4047   else if (fcode == BUILT_IN_BZERO)
4048     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
4049                                 dest, len);
4050   else
4051     gcc_unreachable ();
4052   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4053   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
4054   return expand_call (fn, target, target == const0_rtx);
4055 }
4056
4057 /* Expand expression EXP, which is a call to the bzero builtin.  Return
4058    NULL_RTX if we failed the caller should emit a normal call.  */
4059
4060 static rtx
4061 expand_builtin_bzero (tree exp)
4062 {
4063   tree dest, size;
4064   location_t loc = EXPR_LOCATION (exp);
4065
4066   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4067     return NULL_RTX;
4068
4069   dest = CALL_EXPR_ARG (exp, 0);
4070   size = CALL_EXPR_ARG (exp, 1);
4071
4072   /* New argument list transforming bzero(ptr x, int y) to
4073      memset(ptr x, int 0, size_t y).   This is done this way
4074      so that if it isn't expanded inline, we fallback to
4075      calling bzero instead of memset.  */
4076
4077   return expand_builtin_memset_args (dest, integer_zero_node,
4078                                      fold_convert_loc (loc, sizetype, size),
4079                                      const0_rtx, VOIDmode, exp);
4080 }
4081
4082 /* Expand expression EXP, which is a call to the memcmp built-in function.
4083    Return NULL_RTX if we failed and the
4084    caller should emit a normal call, otherwise try to get the result in
4085    TARGET, if convenient (and in mode MODE, if that's convenient).  */
4086
4087 static rtx
4088 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4089                        ATTRIBUTE_UNUSED enum machine_mode mode)
4090 {
4091   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4092
4093   if (!validate_arglist (exp,
4094                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4095     return NULL_RTX;
4096
4097 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4098   {
4099     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4100     rtx result;
4101     rtx insn;
4102     tree arg1 = CALL_EXPR_ARG (exp, 0);
4103     tree arg2 = CALL_EXPR_ARG (exp, 1);
4104     tree len = CALL_EXPR_ARG (exp, 2);
4105
4106     unsigned int arg1_align
4107       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4108     unsigned int arg2_align
4109       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4110     enum machine_mode insn_mode;
4111
4112 #ifdef HAVE_cmpmemsi
4113     if (HAVE_cmpmemsi)
4114       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
4115     else
4116 #endif
4117 #ifdef HAVE_cmpstrnsi
4118     if (HAVE_cmpstrnsi)
4119       insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4120     else
4121 #endif
4122       return NULL_RTX;
4123
4124     /* If we don't have POINTER_TYPE, call the function.  */
4125     if (arg1_align == 0 || arg2_align == 0)
4126       return NULL_RTX;
4127
4128     /* Make a place to write the result of the instruction.  */
4129     result = target;
4130     if (! (result != 0
4131            && REG_P (result) && GET_MODE (result) == insn_mode
4132            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4133       result = gen_reg_rtx (insn_mode);
4134
4135     arg1_rtx = get_memory_rtx (arg1, len);
4136     arg2_rtx = get_memory_rtx (arg2, len);
4137     arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
4138
4139     /* Set MEM_SIZE as appropriate.  */
4140     if (CONST_INT_P (arg3_rtx))
4141       {
4142         set_mem_size (arg1_rtx, arg3_rtx);
4143         set_mem_size (arg2_rtx, arg3_rtx);
4144       }
4145
4146 #ifdef HAVE_cmpmemsi
4147     if (HAVE_cmpmemsi)
4148       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4149                            GEN_INT (MIN (arg1_align, arg2_align)));
4150     else
4151 #endif
4152 #ifdef HAVE_cmpstrnsi
4153     if (HAVE_cmpstrnsi)
4154       insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4155                             GEN_INT (MIN (arg1_align, arg2_align)));
4156     else
4157 #endif
4158       gcc_unreachable ();
4159
4160     if (insn)
4161       emit_insn (insn);
4162     else
4163       emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
4164                                TYPE_MODE (integer_type_node), 3,
4165                                XEXP (arg1_rtx, 0), Pmode,
4166                                XEXP (arg2_rtx, 0), Pmode,
4167                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
4168                                                 TYPE_UNSIGNED (sizetype)),
4169                                TYPE_MODE (sizetype));
4170
4171     /* Return the value in the proper mode for this function.  */
4172     mode = TYPE_MODE (TREE_TYPE (exp));
4173     if (GET_MODE (result) == mode)
4174       return result;
4175     else if (target != 0)
4176       {
4177         convert_move (target, result, 0);
4178         return target;
4179       }
4180     else
4181       return convert_to_mode (mode, result, 0);
4182   }
4183 #endif
4184
4185   return NULL_RTX;
4186 }
4187
4188 /* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
4189    if we failed the caller should emit a normal call, otherwise try to get
4190    the result in TARGET, if convenient.  */
4191
4192 static rtx
4193 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
4194 {
4195   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4196     return NULL_RTX;
4197
4198 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4199   if (direct_optab_handler (cmpstr_optab, SImode) != CODE_FOR_nothing
4200       || direct_optab_handler (cmpstrn_optab, SImode) != CODE_FOR_nothing)
4201     {
4202       rtx arg1_rtx, arg2_rtx;
4203       rtx result, insn = NULL_RTX;
4204       tree fndecl, fn;
4205       tree arg1 = CALL_EXPR_ARG (exp, 0);
4206       tree arg2 = CALL_EXPR_ARG (exp, 1);
4207
4208       unsigned int arg1_align
4209         = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4210       unsigned int arg2_align
4211         = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4212
4213       /* If we don't have POINTER_TYPE, call the function.  */
4214       if (arg1_align == 0 || arg2_align == 0)
4215         return NULL_RTX;
4216
4217       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
4218       arg1 = builtin_save_expr (arg1);
4219       arg2 = builtin_save_expr (arg2);
4220
4221       arg1_rtx = get_memory_rtx (arg1, NULL);
4222       arg2_rtx = get_memory_rtx (arg2, NULL);
4223
4224 #ifdef HAVE_cmpstrsi
4225       /* Try to call cmpstrsi.  */
4226       if (HAVE_cmpstrsi)
4227         {
4228           enum machine_mode insn_mode
4229             = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4230
4231           /* Make a place to write the result of the instruction.  */
4232           result = target;
4233           if (! (result != 0
4234                  && REG_P (result) && GET_MODE (result) == insn_mode
4235                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4236             result = gen_reg_rtx (insn_mode);
4237
4238           insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4239                                GEN_INT (MIN (arg1_align, arg2_align)));
4240         }
4241 #endif
4242 #ifdef HAVE_cmpstrnsi
4243       /* Try to determine at least one length and call cmpstrnsi.  */
4244       if (!insn && HAVE_cmpstrnsi)
4245         {
4246           tree len;
4247           rtx arg3_rtx;
4248
4249           enum machine_mode insn_mode
4250             = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4251           tree len1 = c_strlen (arg1, 1);
4252           tree len2 = c_strlen (arg2, 1);
4253
4254           if (len1)
4255             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4256           if (len2)
4257             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4258
4259           /* If we don't have a constant length for the first, use the length
4260              of the second, if we know it.  We don't require a constant for
4261              this case; some cost analysis could be done if both are available
4262              but neither is constant.  For now, assume they're equally cheap,
4263              unless one has side effects.  If both strings have constant lengths,
4264              use the smaller.  */
4265
4266           if (!len1)
4267             len = len2;
4268           else if (!len2)
4269             len = len1;
4270           else if (TREE_SIDE_EFFECTS (len1))
4271             len = len2;
4272           else if (TREE_SIDE_EFFECTS (len2))
4273             len = len1;
4274           else if (TREE_CODE (len1) != INTEGER_CST)
4275             len = len2;
4276           else if (TREE_CODE (len2) != INTEGER_CST)
4277             len = len1;
4278           else if (tree_int_cst_lt (len1, len2))
4279             len = len1;
4280           else
4281             len = len2;
4282
4283           /* If both arguments have side effects, we cannot optimize.  */
4284           if (!len || TREE_SIDE_EFFECTS (len))
4285             goto do_libcall;
4286
4287           arg3_rtx = expand_normal (len);
4288
4289           /* Make a place to write the result of the instruction.  */
4290           result = target;
4291           if (! (result != 0
4292                  && REG_P (result) && GET_MODE (result) == insn_mode
4293                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4294             result = gen_reg_rtx (insn_mode);
4295
4296           insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4297                                 GEN_INT (MIN (arg1_align, arg2_align)));
4298         }
4299 #endif
4300
4301       if (insn)
4302         {
4303           enum machine_mode mode;
4304           emit_insn (insn);
4305
4306           /* Return the value in the proper mode for this function.  */
4307           mode = TYPE_MODE (TREE_TYPE (exp));
4308           if (GET_MODE (result) == mode)
4309             return result;
4310           if (target == 0)
4311             return convert_to_mode (mode, result, 0);
4312           convert_move (target, result, 0);
4313           return target;
4314         }
4315
4316       /* Expand the library call ourselves using a stabilized argument
4317          list to avoid re-evaluating the function's arguments twice.  */
4318 #ifdef HAVE_cmpstrnsi
4319     do_libcall:
4320 #endif
4321       fndecl = get_callee_fndecl (exp);
4322       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
4323       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4324       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4325       return expand_call (fn, target, target == const0_rtx);
4326     }
4327 #endif
4328   return NULL_RTX;
4329 }
4330
4331 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4332    NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4333    the result in TARGET, if convenient.  */
4334
4335 static rtx
4336 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4337                         ATTRIBUTE_UNUSED enum machine_mode mode)
4338 {
4339   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4340
4341   if (!validate_arglist (exp,
4342                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4343     return NULL_RTX;
4344
4345   /* If c_strlen can determine an expression for one of the string
4346      lengths, and it doesn't have side effects, then emit cmpstrnsi
4347      using length MIN(strlen(string)+1, arg3).  */
4348 #ifdef HAVE_cmpstrnsi
4349   if (HAVE_cmpstrnsi)
4350   {
4351     tree len, len1, len2;
4352     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4353     rtx result, insn;
4354     tree fndecl, fn;
4355     tree arg1 = CALL_EXPR_ARG (exp, 0);
4356     tree arg2 = CALL_EXPR_ARG (exp, 1);
4357     tree arg3 = CALL_EXPR_ARG (exp, 2);
4358
4359     unsigned int arg1_align
4360       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4361     unsigned int arg2_align
4362       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4363     enum machine_mode insn_mode
4364       = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4365
4366     len1 = c_strlen (arg1, 1);
4367     len2 = c_strlen (arg2, 1);
4368
4369     if (len1)
4370       len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
4371     if (len2)
4372       len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
4373
4374     /* If we don't have a constant length for the first, use the length
4375        of the second, if we know it.  We don't require a constant for
4376        this case; some cost analysis could be done if both are available
4377        but neither is constant.  For now, assume they're equally cheap,
4378        unless one has side effects.  If both strings have constant lengths,
4379        use the smaller.  */
4380
4381     if (!len1)
4382       len = len2;
4383     else if (!len2)
4384       len = len1;
4385     else if (TREE_SIDE_EFFECTS (len1))
4386       len = len2;
4387     else if (TREE_SIDE_EFFECTS (len2))
4388       len = len1;
4389     else if (TREE_CODE (len1) != INTEGER_CST)
4390       len = len2;
4391     else if (TREE_CODE (len2) != INTEGER_CST)
4392       len = len1;
4393     else if (tree_int_cst_lt (len1, len2))
4394       len = len1;
4395     else
4396       len = len2;
4397
4398     /* If both arguments have side effects, we cannot optimize.  */
4399     if (!len || TREE_SIDE_EFFECTS (len))
4400       return NULL_RTX;
4401
4402     /* The actual new length parameter is MIN(len,arg3).  */
4403     len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4404                        fold_convert_loc (loc, TREE_TYPE (len), arg3));
4405
4406     /* If we don't have POINTER_TYPE, call the function.  */
4407     if (arg1_align == 0 || arg2_align == 0)
4408       return NULL_RTX;
4409
4410     /* Make a place to write the result of the instruction.  */
4411     result = target;
4412     if (! (result != 0
4413            && REG_P (result) && GET_MODE (result) == insn_mode
4414            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4415       result = gen_reg_rtx (insn_mode);
4416
4417     /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
4418     arg1 = builtin_save_expr (arg1);
4419     arg2 = builtin_save_expr (arg2);
4420     len = builtin_save_expr (len);
4421
4422     arg1_rtx = get_memory_rtx (arg1, len);
4423     arg2_rtx = get_memory_rtx (arg2, len);
4424     arg3_rtx = expand_normal (len);
4425     insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4426                           GEN_INT (MIN (arg1_align, arg2_align)));
4427     if (insn)
4428       {
4429         emit_insn (insn);
4430
4431         /* Return the value in the proper mode for this function.  */
4432         mode = TYPE_MODE (TREE_TYPE (exp));
4433         if (GET_MODE (result) == mode)
4434           return result;
4435         if (target == 0)
4436           return convert_to_mode (mode, result, 0);
4437         convert_move (target, result, 0);
4438         return target;
4439       }
4440
4441     /* Expand the library call ourselves using a stabilized argument
4442        list to avoid re-evaluating the function's arguments twice.  */
4443     fndecl = get_callee_fndecl (exp);
4444     fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
4445                                 arg1, arg2, len);
4446     gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4447     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4448     return expand_call (fn, target, target == const0_rtx);
4449   }
4450 #endif
4451   return NULL_RTX;
4452 }
4453
4454 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4455    if that's convenient.  */
4456
4457 rtx
4458 expand_builtin_saveregs (void)
4459 {
4460   rtx val, seq;
4461
4462   /* Don't do __builtin_saveregs more than once in a function.
4463      Save the result of the first call and reuse it.  */
4464   if (saveregs_value != 0)
4465     return saveregs_value;
4466
4467   /* When this function is called, it means that registers must be
4468      saved on entry to this function.  So we migrate the call to the
4469      first insn of this function.  */
4470
4471   start_sequence ();
4472
4473   /* Do whatever the machine needs done in this case.  */
4474   val = targetm.calls.expand_builtin_saveregs ();
4475
4476   seq = get_insns ();
4477   end_sequence ();
4478
4479   saveregs_value = val;
4480
4481   /* Put the insns after the NOTE that starts the function.  If this
4482      is inside a start_sequence, make the outer-level insn chain current, so
4483      the code is placed at the start of the function.  */
4484   push_topmost_sequence ();
4485   emit_insn_after (seq, entry_of_function ());
4486   pop_topmost_sequence ();
4487
4488   return val;
4489 }
4490
4491 /* Expand a call to __builtin_next_arg.  */
4492
4493 static rtx
4494 expand_builtin_next_arg (void)
4495 {
4496   /* Checking arguments is already done in fold_builtin_next_arg
4497      that must be called before this function.  */
4498   return expand_binop (ptr_mode, add_optab,
4499                        crtl->args.internal_arg_pointer,
4500                        crtl->args.arg_offset_rtx,
4501                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
4502 }
4503
4504 /* Make it easier for the backends by protecting the valist argument
4505    from multiple evaluations.  */
4506
4507 static tree
4508 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4509 {
4510   tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4511
4512   /* The current way of determining the type of valist is completely
4513      bogus.  We should have the information on the va builtin instead.  */
4514   if (!vatype)
4515     vatype = targetm.fn_abi_va_list (cfun->decl);
4516
4517   if (TREE_CODE (vatype) == ARRAY_TYPE)
4518     {
4519       if (TREE_SIDE_EFFECTS (valist))
4520         valist = save_expr (valist);
4521
4522       /* For this case, the backends will be expecting a pointer to
4523          vatype, but it's possible we've actually been given an array
4524          (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4525          So fix it.  */
4526       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4527         {
4528           tree p1 = build_pointer_type (TREE_TYPE (vatype));
4529           valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4530         }
4531     }
4532   else
4533     {
4534       tree pt = build_pointer_type (vatype);
4535
4536       if (! needs_lvalue)
4537         {
4538           if (! TREE_SIDE_EFFECTS (valist))
4539             return valist;
4540
4541           valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4542           TREE_SIDE_EFFECTS (valist) = 1;
4543         }
4544
4545       if (TREE_SIDE_EFFECTS (valist))
4546         valist = save_expr (valist);
4547       valist = fold_build2_loc (loc, MEM_REF,
4548                                 vatype, valist, build_int_cst (pt, 0));
4549     }
4550
4551   return valist;
4552 }
4553
4554 /* The "standard" definition of va_list is void*.  */
4555
4556 tree
4557 std_build_builtin_va_list (void)
4558 {
4559   return ptr_type_node;
4560 }
4561
4562 /* The "standard" abi va_list is va_list_type_node.  */
4563
4564 tree
4565 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4566 {
4567   return va_list_type_node;
4568 }
4569
4570 /* The "standard" type of va_list is va_list_type_node.  */
4571
4572 tree
4573 std_canonical_va_list_type (tree type)
4574 {
4575   tree wtype, htype;
4576
4577   if (INDIRECT_REF_P (type))
4578     type = TREE_TYPE (type);
4579   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4580     type = TREE_TYPE (type);
4581   wtype = va_list_type_node;
4582   htype = type;
4583   /* Treat structure va_list types.  */
4584   if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4585     htype = TREE_TYPE (htype);
4586   else if (TREE_CODE (wtype) == ARRAY_TYPE)
4587     {
4588       /* If va_list is an array type, the argument may have decayed
4589          to a pointer type, e.g. by being passed to another function.
4590          In that case, unwrap both types so that we can compare the
4591          underlying records.  */
4592       if (TREE_CODE (htype) == ARRAY_TYPE
4593           || POINTER_TYPE_P (htype))
4594         {
4595           wtype = TREE_TYPE (wtype);
4596           htype = TREE_TYPE (htype);
4597         }
4598     }
4599   if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4600     return va_list_type_node;
4601
4602   return NULL_TREE;
4603 }
4604
4605 /* The "standard" implementation of va_start: just assign `nextarg' to
4606    the variable.  */
4607
4608 void
4609 std_expand_builtin_va_start (tree valist, rtx nextarg)
4610 {
4611   rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4612   convert_move (va_r, nextarg, 0);
4613 }
4614
4615 /* Expand EXP, a call to __builtin_va_start.  */
4616
4617 static rtx
4618 expand_builtin_va_start (tree exp)
4619 {
4620   rtx nextarg;
4621   tree valist;
4622   location_t loc = EXPR_LOCATION (exp);
4623
4624   if (call_expr_nargs (exp) < 2)
4625     {
4626       error_at (loc, "too few arguments to function %<va_start%>");
4627       return const0_rtx;
4628     }
4629
4630   if (fold_builtin_next_arg (exp, true))
4631     return const0_rtx;
4632
4633   nextarg = expand_builtin_next_arg ();
4634   valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4635
4636   if (targetm.expand_builtin_va_start)
4637     targetm.expand_builtin_va_start (valist, nextarg);
4638   else
4639     std_expand_builtin_va_start (valist, nextarg);
4640
4641   return const0_rtx;
4642 }
4643
4644 /* The "standard" implementation of va_arg: read the value from the
4645    current (padded) address and increment by the (padded) size.  */
4646
4647 tree
4648 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4649                           gimple_seq *post_p)
4650 {
4651   tree addr, t, type_size, rounded_size, valist_tmp;
4652   unsigned HOST_WIDE_INT align, boundary;
4653   bool indirect;
4654
4655 #ifdef ARGS_GROW_DOWNWARD
4656   /* All of the alignment and movement below is for args-grow-up machines.
4657      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4658      implement their own specialized gimplify_va_arg_expr routines.  */
4659   gcc_unreachable ();
4660 #endif
4661
4662   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4663   if (indirect)
4664     type = build_pointer_type (type);
4665
4666   align = PARM_BOUNDARY / BITS_PER_UNIT;
4667   boundary = targetm.calls.function_arg_boundary (TYPE_MODE (type), type);
4668
4669   /* When we align parameter on stack for caller, if the parameter
4670      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4671      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
4672      here with caller.  */
4673   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4674     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4675
4676   boundary /= BITS_PER_UNIT;
4677
4678   /* Hoist the valist value into a temporary for the moment.  */
4679   valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4680
4681   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
4682      requires greater alignment, we must perform dynamic alignment.  */
4683   if (boundary > align
4684       && !integer_zerop (TYPE_SIZE (type)))
4685     {
4686       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4687                   fold_build2 (POINTER_PLUS_EXPR,
4688                                TREE_TYPE (valist),
4689                                valist_tmp, size_int (boundary - 1)));
4690       gimplify_and_add (t, pre_p);
4691
4692       t = fold_convert (sizetype, valist_tmp);
4693       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4694                   fold_convert (TREE_TYPE (valist),
4695                                 fold_build2 (BIT_AND_EXPR, sizetype, t,
4696                                              size_int (-boundary))));
4697       gimplify_and_add (t, pre_p);
4698     }
4699   else
4700     boundary = align;
4701
4702   /* If the actual alignment is less than the alignment of the type,
4703      adjust the type accordingly so that we don't assume strict alignment
4704      when dereferencing the pointer.  */
4705   boundary *= BITS_PER_UNIT;
4706   if (boundary < TYPE_ALIGN (type))
4707     {
4708       type = build_variant_type_copy (type);
4709       TYPE_ALIGN (type) = boundary;
4710     }
4711
4712   /* Compute the rounded size of the type.  */
4713   type_size = size_in_bytes (type);
4714   rounded_size = round_up (type_size, align);
4715
4716   /* Reduce rounded_size so it's sharable with the postqueue.  */
4717   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4718
4719   /* Get AP.  */
4720   addr = valist_tmp;
4721   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4722     {
4723       /* Small args are padded downward.  */
4724       t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4725                        rounded_size, size_int (align));
4726       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4727                        size_binop (MINUS_EXPR, rounded_size, type_size));
4728       addr = fold_build2 (POINTER_PLUS_EXPR,
4729                           TREE_TYPE (addr), addr, t);
4730     }
4731
4732   /* Compute new value for AP.  */
4733   t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist), valist_tmp, rounded_size);
4734   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4735   gimplify_and_add (t, pre_p);
4736
4737   addr = fold_convert (build_pointer_type (type), addr);
4738
4739   if (indirect)
4740     addr = build_va_arg_indirect_ref (addr);
4741
4742   return build_va_arg_indirect_ref (addr);
4743 }
4744
4745 /* Build an indirect-ref expression over the given TREE, which represents a
4746    piece of a va_arg() expansion.  */
4747 tree
4748 build_va_arg_indirect_ref (tree addr)
4749 {
4750   addr = build_fold_indirect_ref_loc (EXPR_LOCATION (addr), addr);
4751
4752   if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF.  */
4753     mf_mark (addr);
4754
4755   return addr;
4756 }
4757
4758 /* Return a dummy expression of type TYPE in order to keep going after an
4759    error.  */
4760
4761 static tree
4762 dummy_object (tree type)
4763 {
4764   tree t = build_int_cst (build_pointer_type (type), 0);
4765   return build2 (MEM_REF, type, t, t);
4766 }
4767
4768 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4769    builtin function, but a very special sort of operator.  */
4770
4771 enum gimplify_status
4772 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4773 {
4774   tree promoted_type, have_va_type;
4775   tree valist = TREE_OPERAND (*expr_p, 0);
4776   tree type = TREE_TYPE (*expr_p);
4777   tree t;
4778   location_t loc = EXPR_LOCATION (*expr_p);
4779
4780   /* Verify that valist is of the proper type.  */
4781   have_va_type = TREE_TYPE (valist);
4782   if (have_va_type == error_mark_node)
4783     return GS_ERROR;
4784   have_va_type = targetm.canonical_va_list_type (have_va_type);
4785
4786   if (have_va_type == NULL_TREE)
4787     {
4788       error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4789       return GS_ERROR;
4790     }
4791
4792   /* Generate a diagnostic for requesting data of a type that cannot
4793      be passed through `...' due to type promotion at the call site.  */
4794   if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4795            != type)
4796     {
4797       static bool gave_help;
4798       bool warned;
4799
4800       /* Unfortunately, this is merely undefined, rather than a constraint
4801          violation, so we cannot make this an error.  If this call is never
4802          executed, the program is still strictly conforming.  */
4803       warned = warning_at (loc, 0,
4804                            "%qT is promoted to %qT when passed through %<...%>",
4805                            type, promoted_type);
4806       if (!gave_help && warned)
4807         {
4808           gave_help = true;
4809           inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4810                   promoted_type, type);
4811         }
4812
4813       /* We can, however, treat "undefined" any way we please.
4814          Call abort to encourage the user to fix the program.  */
4815       if (warned)
4816         inform (loc, "if this code is reached, the program will abort");
4817       /* Before the abort, allow the evaluation of the va_list
4818          expression to exit or longjmp.  */
4819       gimplify_and_add (valist, pre_p);
4820       t = build_call_expr_loc (loc,
4821                                implicit_built_in_decls[BUILT_IN_TRAP], 0);
4822       gimplify_and_add (t, pre_p);
4823
4824       /* This is dead code, but go ahead and finish so that the
4825          mode of the result comes out right.  */
4826       *expr_p = dummy_object (type);
4827       return GS_ALL_DONE;
4828     }
4829   else
4830     {
4831       /* Make it easier for the backends by protecting the valist argument
4832          from multiple evaluations.  */
4833       if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4834         {
4835           /* For this case, the backends will be expecting a pointer to
4836              TREE_TYPE (abi), but it's possible we've
4837              actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4838              So fix it.  */
4839           if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4840             {
4841               tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4842               valist = fold_convert_loc (loc, p1,
4843                                          build_fold_addr_expr_loc (loc, valist));
4844             }
4845
4846           gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4847         }
4848       else
4849         gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4850
4851       if (!targetm.gimplify_va_arg_expr)
4852         /* FIXME: Once most targets are converted we should merely
4853            assert this is non-null.  */
4854         return GS_ALL_DONE;
4855
4856       *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4857       return GS_OK;
4858     }
4859 }
4860
4861 /* Expand EXP, a call to __builtin_va_end.  */
4862
4863 static rtx
4864 expand_builtin_va_end (tree exp)
4865 {
4866   tree valist = CALL_EXPR_ARG (exp, 0);
4867
4868   /* Evaluate for side effects, if needed.  I hate macros that don't
4869      do that.  */
4870   if (TREE_SIDE_EFFECTS (valist))
4871     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4872
4873   return const0_rtx;
4874 }
4875
4876 /* Expand EXP, a call to __builtin_va_copy.  We do this as a
4877    builtin rather than just as an assignment in stdarg.h because of the
4878    nastiness of array-type va_list types.  */
4879
4880 static rtx
4881 expand_builtin_va_copy (tree exp)
4882 {
4883   tree dst, src, t;
4884   location_t loc = EXPR_LOCATION (exp);
4885
4886   dst = CALL_EXPR_ARG (exp, 0);
4887   src = CALL_EXPR_ARG (exp, 1);
4888
4889   dst = stabilize_va_list_loc (loc, dst, 1);
4890   src = stabilize_va_list_loc (loc, src, 0);
4891
4892   gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4893
4894   if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4895     {
4896       t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4897       TREE_SIDE_EFFECTS (t) = 1;
4898       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4899     }
4900   else
4901     {
4902       rtx dstb, srcb, size;
4903
4904       /* Evaluate to pointers.  */
4905       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4906       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4907       size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4908                   NULL_RTX, VOIDmode, EXPAND_NORMAL);
4909
4910       dstb = convert_memory_address (Pmode, dstb);
4911       srcb = convert_memory_address (Pmode, srcb);
4912
4913       /* "Dereference" to BLKmode memories.  */
4914       dstb = gen_rtx_MEM (BLKmode, dstb);
4915       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4916       set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4917       srcb = gen_rtx_MEM (BLKmode, srcb);
4918       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4919       set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4920
4921       /* Copy.  */
4922       emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4923     }
4924
4925   return const0_rtx;
4926 }
4927
4928 /* Expand a call to one of the builtin functions __builtin_frame_address or
4929    __builtin_return_address.  */
4930
4931 static rtx
4932 expand_builtin_frame_address (tree fndecl, tree exp)
4933 {
4934   /* The argument must be a nonnegative integer constant.
4935      It counts the number of frames to scan up the stack.
4936      The value is the return address saved in that frame.  */
4937   if (call_expr_nargs (exp) == 0)
4938     /* Warning about missing arg was already issued.  */
4939     return const0_rtx;
4940   else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4941     {
4942       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4943         error ("invalid argument to %<__builtin_frame_address%>");
4944       else
4945         error ("invalid argument to %<__builtin_return_address%>");
4946       return const0_rtx;
4947     }
4948   else
4949     {
4950       rtx tem
4951         = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4952                                       tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4953
4954       /* Some ports cannot access arbitrary stack frames.  */
4955       if (tem == NULL)
4956         {
4957           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4958             warning (0, "unsupported argument to %<__builtin_frame_address%>");
4959           else
4960             warning (0, "unsupported argument to %<__builtin_return_address%>");
4961           return const0_rtx;
4962         }
4963
4964       /* For __builtin_frame_address, return what we've got.  */
4965       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4966         return tem;
4967
4968       if (!REG_P (tem)
4969           && ! CONSTANT_P (tem))
4970         tem = copy_to_mode_reg (Pmode, tem);
4971       return tem;
4972     }
4973 }
4974
4975 /* Expand EXP, a call to the alloca builtin.  Return NULL_RTX if we
4976    failed and the caller should emit a normal call.  CANNOT_ACCUMULATE
4977    is the same as for allocate_dynamic_stack_space.  */
4978
4979 static rtx
4980 expand_builtin_alloca (tree exp, bool cannot_accumulate)
4981 {
4982   rtx op0;
4983   rtx result;
4984
4985   /* Emit normal call if marked not-inlineable.  */
4986   if (CALL_CANNOT_INLINE_P (exp))
4987     return NULL_RTX;
4988
4989   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4990     return NULL_RTX;
4991
4992   /* Compute the argument.  */
4993   op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4994
4995   /* Allocate the desired space.  */
4996   result = allocate_dynamic_stack_space (op0, 0, BIGGEST_ALIGNMENT,
4997                                          cannot_accumulate);
4998   result = convert_memory_address (ptr_mode, result);
4999
5000   return result;
5001 }
5002
5003 /* Expand a call to a bswap builtin with argument ARG0.  MODE
5004    is the mode to expand with.  */
5005
5006 static rtx
5007 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
5008 {
5009   enum machine_mode mode;
5010   tree arg;
5011   rtx op0;
5012
5013   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5014     return NULL_RTX;
5015
5016   arg = CALL_EXPR_ARG (exp, 0);
5017   mode = TYPE_MODE (TREE_TYPE (arg));
5018   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5019
5020   target = expand_unop (mode, bswap_optab, op0, target, 1);
5021
5022   gcc_assert (target);
5023
5024   return convert_to_mode (mode, target, 0);
5025 }
5026
5027 /* Expand a call to a unary builtin in EXP.
5028    Return NULL_RTX if a normal call should be emitted rather than expanding the
5029    function in-line.  If convenient, the result should be placed in TARGET.
5030    SUBTARGET may be used as the target for computing one of EXP's operands.  */
5031
5032 static rtx
5033 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
5034                      rtx subtarget, optab op_optab)
5035 {
5036   rtx op0;
5037
5038   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5039     return NULL_RTX;
5040
5041   /* Compute the argument.  */
5042   op0 = expand_expr (CALL_EXPR_ARG (exp, 0),
5043                      (subtarget
5044                       && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0)))
5045                           == GET_MODE (subtarget))) ? subtarget : NULL_RTX,
5046                      VOIDmode, EXPAND_NORMAL);
5047   /* Compute op, into TARGET if possible.
5048      Set TARGET to wherever the result comes back.  */
5049   target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
5050                         op_optab, op0, target, 1);
5051   gcc_assert (target);
5052
5053   return convert_to_mode (target_mode, target, 0);
5054 }
5055
5056 /* Expand a call to __builtin_expect.  We just return our argument
5057    as the builtin_expect semantic should've been already executed by
5058    tree branch prediction pass. */
5059
5060 static rtx
5061 expand_builtin_expect (tree exp, rtx target)
5062 {
5063   tree arg;
5064
5065   if (call_expr_nargs (exp) < 2)
5066     return const0_rtx;
5067   arg = CALL_EXPR_ARG (exp, 0);
5068
5069   target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5070   /* When guessing was done, the hints should be already stripped away.  */
5071   gcc_assert (!flag_guess_branch_prob
5072               || optimize == 0 || seen_error ());
5073   return target;
5074 }
5075
5076 void
5077 expand_builtin_trap (void)
5078 {
5079 #ifdef HAVE_trap
5080   if (HAVE_trap)
5081     emit_insn (gen_trap ());
5082   else
5083 #endif
5084     emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
5085   emit_barrier ();
5086 }
5087
5088 /* Expand a call to __builtin_unreachable.  We do nothing except emit
5089    a barrier saying that control flow will not pass here.
5090
5091    It is the responsibility of the program being compiled to ensure
5092    that control flow does never reach __builtin_unreachable.  */
5093 static void
5094 expand_builtin_unreachable (void)
5095 {
5096   emit_barrier ();
5097 }
5098
5099 /* Expand EXP, a call to fabs, fabsf or fabsl.
5100    Return NULL_RTX if a normal call should be emitted rather than expanding
5101    the function inline.  If convenient, the result should be placed
5102    in TARGET.  SUBTARGET may be used as the target for computing
5103    the operand.  */
5104
5105 static rtx
5106 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
5107 {
5108   enum machine_mode mode;
5109   tree arg;
5110   rtx op0;
5111
5112   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5113     return NULL_RTX;
5114
5115   arg = CALL_EXPR_ARG (exp, 0);
5116   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
5117   mode = TYPE_MODE (TREE_TYPE (arg));
5118   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5119   return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
5120 }
5121
5122 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5123    Return NULL is a normal call should be emitted rather than expanding the
5124    function inline.  If convenient, the result should be placed in TARGET.
5125    SUBTARGET may be used as the target for computing the operand.  */
5126
5127 static rtx
5128 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
5129 {
5130   rtx op0, op1;
5131   tree arg;
5132
5133   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
5134     return NULL_RTX;
5135
5136   arg = CALL_EXPR_ARG (exp, 0);
5137   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5138
5139   arg = CALL_EXPR_ARG (exp, 1);
5140   op1 = expand_normal (arg);
5141
5142   return expand_copysign (op0, op1, target);
5143 }
5144
5145 /* Create a new constant string literal and return a char* pointer to it.
5146    The STRING_CST value is the LEN characters at STR.  */
5147 tree
5148 build_string_literal (int len, const char *str)
5149 {
5150   tree t, elem, index, type;
5151
5152   t = build_string (len, str);
5153   elem = build_type_variant (char_type_node, 1, 0);
5154   index = build_index_type (size_int (len - 1));
5155   type = build_array_type (elem, index);
5156   TREE_TYPE (t) = type;
5157   TREE_CONSTANT (t) = 1;
5158   TREE_READONLY (t) = 1;
5159   TREE_STATIC (t) = 1;
5160
5161   type = build_pointer_type (elem);
5162   t = build1 (ADDR_EXPR, type,
5163               build4 (ARRAY_REF, elem,
5164                       t, integer_zero_node, NULL_TREE, NULL_TREE));
5165   return t;
5166 }
5167
5168 /* Expand a call to __builtin___clear_cache.  */
5169
5170 static rtx
5171 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
5172 {
5173 #ifndef HAVE_clear_cache
5174 #ifdef CLEAR_INSN_CACHE
5175   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5176      does something.  Just do the default expansion to a call to
5177      __clear_cache().  */
5178   return NULL_RTX;
5179 #else
5180   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5181      does nothing.  There is no need to call it.  Do nothing.  */
5182   return const0_rtx;
5183 #endif /* CLEAR_INSN_CACHE */
5184 #else
5185   /* We have a "clear_cache" insn, and it will handle everything.  */
5186   tree begin, end;
5187   rtx begin_rtx, end_rtx;
5188
5189   /* We must not expand to a library call.  If we did, any
5190      fallback library function in libgcc that might contain a call to
5191      __builtin___clear_cache() would recurse infinitely.  */
5192   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5193     {
5194       error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5195       return const0_rtx;
5196     }
5197
5198   if (HAVE_clear_cache)
5199     {
5200       struct expand_operand ops[2];
5201
5202       begin = CALL_EXPR_ARG (exp, 0);
5203       begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
5204
5205       end = CALL_EXPR_ARG (exp, 1);
5206       end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
5207
5208       create_address_operand (&ops[0], begin_rtx);
5209       create_address_operand (&ops[1], end_rtx);
5210       if (maybe_expand_insn (CODE_FOR_clear_cache, 2, ops))
5211         return const0_rtx;
5212     }
5213   return const0_rtx;
5214 #endif /* HAVE_clear_cache */
5215 }
5216
5217 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT.  */
5218
5219 static rtx
5220 round_trampoline_addr (rtx tramp)
5221 {
5222   rtx temp, addend, mask;
5223
5224   /* If we don't need too much alignment, we'll have been guaranteed
5225      proper alignment by get_trampoline_type.  */
5226   if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5227     return tramp;
5228
5229   /* Round address up to desired boundary.  */
5230   temp = gen_reg_rtx (Pmode);
5231   addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5232   mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5233
5234   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5235                                temp, 0, OPTAB_LIB_WIDEN);
5236   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5237                                temp, 0, OPTAB_LIB_WIDEN);
5238
5239   return tramp;
5240 }
5241
5242 static rtx
5243 expand_builtin_init_trampoline (tree exp)
5244 {
5245   tree t_tramp, t_func, t_chain;
5246   rtx m_tramp, r_tramp, r_chain, tmp;
5247
5248   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5249                          POINTER_TYPE, VOID_TYPE))
5250     return NULL_RTX;
5251
5252   t_tramp = CALL_EXPR_ARG (exp, 0);
5253   t_func = CALL_EXPR_ARG (exp, 1);
5254   t_chain = CALL_EXPR_ARG (exp, 2);
5255
5256   r_tramp = expand_normal (t_tramp);
5257   m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
5258   MEM_NOTRAP_P (m_tramp) = 1;
5259
5260   /* The TRAMP argument should be the address of a field within the
5261      local function's FRAME decl.  Let's see if we can fill in the
5262      to fill in the MEM_ATTRs for this memory.  */
5263   if (TREE_CODE (t_tramp) == ADDR_EXPR)
5264     set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
5265                                      true, 0);
5266
5267   tmp = round_trampoline_addr (r_tramp);
5268   if (tmp != r_tramp)
5269     {
5270       m_tramp = change_address (m_tramp, BLKmode, tmp);
5271       set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
5272       set_mem_size (m_tramp, GEN_INT (TRAMPOLINE_SIZE));
5273     }
5274
5275   /* The FUNC argument should be the address of the nested function.
5276      Extract the actual function decl to pass to the hook.  */
5277   gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
5278   t_func = TREE_OPERAND (t_func, 0);
5279   gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
5280
5281   r_chain = expand_normal (t_chain);
5282
5283   /* Generate insns to initialize the trampoline.  */
5284   targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
5285
5286   trampolines_created = 1;
5287
5288   warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
5289               "trampoline generated for nested function %qD", t_func);
5290
5291   return const0_rtx;
5292 }
5293
5294 static rtx
5295 expand_builtin_adjust_trampoline (tree exp)
5296 {
5297   rtx tramp;
5298
5299   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5300     return NULL_RTX;
5301
5302   tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5303   tramp = round_trampoline_addr (tramp);
5304   if (targetm.calls.trampoline_adjust_address)
5305     tramp = targetm.calls.trampoline_adjust_address (tramp);
5306
5307   return tramp;
5308 }
5309
5310 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5311    function.  The function first checks whether the back end provides
5312    an insn to implement signbit for the respective mode.  If not, it
5313    checks whether the floating point format of the value is such that
5314    the sign bit can be extracted.  If that is not the case, the
5315    function returns NULL_RTX to indicate that a normal call should be
5316    emitted rather than expanding the function in-line.  EXP is the
5317    expression that is a call to the builtin function; if convenient,
5318    the result should be placed in TARGET.  */
5319 static rtx
5320 expand_builtin_signbit (tree exp, rtx target)
5321 {
5322   const struct real_format *fmt;
5323   enum machine_mode fmode, imode, rmode;
5324   tree arg;
5325   int word, bitpos;
5326   enum insn_code icode;
5327   rtx temp;
5328   location_t loc = EXPR_LOCATION (exp);
5329
5330   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5331     return NULL_RTX;
5332
5333   arg = CALL_EXPR_ARG (exp, 0);
5334   fmode = TYPE_MODE (TREE_TYPE (arg));
5335   rmode = TYPE_MODE (TREE_TYPE (exp));
5336   fmt = REAL_MODE_FORMAT (fmode);
5337
5338   arg = builtin_save_expr (arg);
5339
5340   /* Expand the argument yielding a RTX expression. */
5341   temp = expand_normal (arg);
5342
5343   /* Check if the back end provides an insn that handles signbit for the
5344      argument's mode. */
5345   icode = optab_handler (signbit_optab, fmode);
5346   if (icode != CODE_FOR_nothing)
5347     {
5348       rtx last = get_last_insn ();
5349       target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5350       if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
5351         return target;
5352       delete_insns_since (last);
5353     }
5354
5355   /* For floating point formats without a sign bit, implement signbit
5356      as "ARG < 0.0".  */
5357   bitpos = fmt->signbit_ro;
5358   if (bitpos < 0)
5359   {
5360     /* But we can't do this if the format supports signed zero.  */
5361     if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5362       return NULL_RTX;
5363
5364     arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5365                        build_real (TREE_TYPE (arg), dconst0));
5366     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5367   }
5368
5369   if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5370     {
5371       imode = int_mode_for_mode (fmode);
5372       if (imode == BLKmode)
5373         return NULL_RTX;
5374       temp = gen_lowpart (imode, temp);
5375     }
5376   else
5377     {
5378       imode = word_mode;
5379       /* Handle targets with different FP word orders.  */
5380       if (FLOAT_WORDS_BIG_ENDIAN)
5381         word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5382       else
5383         word = bitpos / BITS_PER_WORD;
5384       temp = operand_subword_force (temp, word, fmode);
5385       bitpos = bitpos % BITS_PER_WORD;
5386     }
5387
5388   /* Force the intermediate word_mode (or narrower) result into a
5389      register.  This avoids attempting to create paradoxical SUBREGs
5390      of floating point modes below.  */
5391   temp = force_reg (imode, temp);
5392
5393   /* If the bitpos is within the "result mode" lowpart, the operation
5394      can be implement with a single bitwise AND.  Otherwise, we need
5395      a right shift and an AND.  */
5396
5397   if (bitpos < GET_MODE_BITSIZE (rmode))
5398     {
5399       double_int mask = double_int_setbit (double_int_zero, bitpos);
5400
5401       if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5402         temp = gen_lowpart (rmode, temp);
5403       temp = expand_binop (rmode, and_optab, temp,
5404                            immed_double_int_const (mask, rmode),
5405                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5406     }
5407   else
5408     {
5409       /* Perform a logical right shift to place the signbit in the least
5410          significant bit, then truncate the result to the desired mode
5411          and mask just this bit.  */
5412       temp = expand_shift (RSHIFT_EXPR, imode, temp,
5413                            build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5414       temp = gen_lowpart (rmode, temp);
5415       temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5416                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5417     }
5418
5419   return temp;
5420 }
5421
5422 /* Expand fork or exec calls.  TARGET is the desired target of the
5423    call.  EXP is the call. FN is the
5424    identificator of the actual function.  IGNORE is nonzero if the
5425    value is to be ignored.  */
5426
5427 static rtx
5428 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5429 {
5430   tree id, decl;
5431   tree call;
5432
5433   /* If we are not profiling, just call the function.  */
5434   if (!profile_arc_flag)
5435     return NULL_RTX;
5436
5437   /* Otherwise call the wrapper.  This should be equivalent for the rest of
5438      compiler, so the code does not diverge, and the wrapper may run the
5439      code necessary for keeping the profiling sane.  */
5440
5441   switch (DECL_FUNCTION_CODE (fn))
5442     {
5443     case BUILT_IN_FORK:
5444       id = get_identifier ("__gcov_fork");
5445       break;
5446
5447     case BUILT_IN_EXECL:
5448       id = get_identifier ("__gcov_execl");
5449       break;
5450
5451     case BUILT_IN_EXECV:
5452       id = get_identifier ("__gcov_execv");
5453       break;
5454
5455     case BUILT_IN_EXECLP:
5456       id = get_identifier ("__gcov_execlp");
5457       break;
5458
5459     case BUILT_IN_EXECLE:
5460       id = get_identifier ("__gcov_execle");
5461       break;
5462
5463     case BUILT_IN_EXECVP:
5464       id = get_identifier ("__gcov_execvp");
5465       break;
5466
5467     case BUILT_IN_EXECVE:
5468       id = get_identifier ("__gcov_execve");
5469       break;
5470
5471     default:
5472       gcc_unreachable ();
5473     }
5474
5475   decl = build_decl (DECL_SOURCE_LOCATION (fn),
5476                      FUNCTION_DECL, id, TREE_TYPE (fn));
5477   DECL_EXTERNAL (decl) = 1;
5478   TREE_PUBLIC (decl) = 1;
5479   DECL_ARTIFICIAL (decl) = 1;
5480   TREE_NOTHROW (decl) = 1;
5481   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5482   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5483   call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5484   return expand_call (call, target, ignore);
5485  }
5486
5487
5488 \f
5489 /* Reconstitute a mode for a __sync intrinsic operation.  Since the type of
5490    the pointer in these functions is void*, the tree optimizers may remove
5491    casts.  The mode computed in expand_builtin isn't reliable either, due
5492    to __sync_bool_compare_and_swap.
5493
5494    FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5495    group of builtins.  This gives us log2 of the mode size.  */
5496
5497 static inline enum machine_mode
5498 get_builtin_sync_mode (int fcode_diff)
5499 {
5500   /* The size is not negotiable, so ask not to get BLKmode in return
5501      if the target indicates that a smaller size would be better.  */
5502   return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5503 }
5504
5505 /* Expand the memory expression LOC and return the appropriate memory operand
5506    for the builtin_sync operations.  */
5507
5508 static rtx
5509 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5510 {
5511   rtx addr, mem;
5512
5513   addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
5514   addr = convert_memory_address (Pmode, addr);
5515
5516   /* Note that we explicitly do not want any alias information for this
5517      memory, so that we kill all other live memories.  Otherwise we don't
5518      satisfy the full barrier semantics of the intrinsic.  */
5519   mem = validize_mem (gen_rtx_MEM (mode, addr));
5520
5521   /* The alignment needs to be at least according to that of the mode.  */
5522   set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
5523                            get_pointer_alignment (loc, BIGGEST_ALIGNMENT)));
5524   set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5525   MEM_VOLATILE_P (mem) = 1;
5526
5527   return mem;
5528 }
5529
5530 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5531    EXP is the CALL_EXPR.  CODE is the rtx code
5532    that corresponds to the arithmetic or logical operation from the name;
5533    an exception here is that NOT actually means NAND.  TARGET is an optional
5534    place for us to store the results; AFTER is true if this is the
5535    fetch_and_xxx form.  IGNORE is true if we don't actually care about
5536    the result of the operation at all.  */
5537
5538 static rtx
5539 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5540                                enum rtx_code code, bool after,
5541                                rtx target, bool ignore)
5542 {
5543   rtx val, mem;
5544   enum machine_mode old_mode;
5545   location_t loc = EXPR_LOCATION (exp);
5546
5547   if (code == NOT && warn_sync_nand)
5548     {
5549       tree fndecl = get_callee_fndecl (exp);
5550       enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5551
5552       static bool warned_f_a_n, warned_n_a_f;
5553
5554       switch (fcode)
5555         {
5556         case BUILT_IN_FETCH_AND_NAND_1:
5557         case BUILT_IN_FETCH_AND_NAND_2:
5558         case BUILT_IN_FETCH_AND_NAND_4:
5559         case BUILT_IN_FETCH_AND_NAND_8:
5560         case BUILT_IN_FETCH_AND_NAND_16:
5561
5562           if (warned_f_a_n)
5563             break;
5564
5565           fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
5566           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5567           warned_f_a_n = true;
5568           break;
5569
5570         case BUILT_IN_NAND_AND_FETCH_1:
5571         case BUILT_IN_NAND_AND_FETCH_2:
5572         case BUILT_IN_NAND_AND_FETCH_4:
5573         case BUILT_IN_NAND_AND_FETCH_8:
5574         case BUILT_IN_NAND_AND_FETCH_16:
5575
5576           if (warned_n_a_f)
5577             break;
5578
5579           fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
5580           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5581           warned_n_a_f = true;
5582           break;
5583
5584         default:
5585           gcc_unreachable ();
5586         }
5587     }
5588
5589   /* Expand the operands.  */
5590   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5591
5592   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5593   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5594      of CONST_INTs, where we know the old_mode only from the call argument.  */
5595   old_mode = GET_MODE (val);
5596   if (old_mode == VOIDmode)
5597     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5598   val = convert_modes (mode, old_mode, val, 1);
5599
5600   if (ignore)
5601     return expand_sync_operation (mem, val, code);
5602   else
5603     return expand_sync_fetch_operation (mem, val, code, after, target);
5604 }
5605
5606 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5607    intrinsics. EXP is the CALL_EXPR.  IS_BOOL is
5608    true if this is the boolean form.  TARGET is a place for us to store the
5609    results; this is NOT optional if IS_BOOL is true.  */
5610
5611 static rtx
5612 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5613                                  bool is_bool, rtx target)
5614 {
5615   rtx old_val, new_val, mem;
5616   enum machine_mode old_mode;
5617
5618   /* Expand the operands.  */
5619   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5620
5621
5622   old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX,
5623                          mode, EXPAND_NORMAL);
5624   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5625      of CONST_INTs, where we know the old_mode only from the call argument.  */
5626   old_mode = GET_MODE (old_val);
5627   if (old_mode == VOIDmode)
5628     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5629   old_val = convert_modes (mode, old_mode, old_val, 1);
5630
5631   new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL_RTX,
5632                          mode, EXPAND_NORMAL);
5633   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5634      of CONST_INTs, where we know the old_mode only from the call argument.  */
5635   old_mode = GET_MODE (new_val);
5636   if (old_mode == VOIDmode)
5637     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2)));
5638   new_val = convert_modes (mode, old_mode, new_val, 1);
5639
5640   if (is_bool)
5641     return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5642   else
5643     return expand_val_compare_and_swap (mem, old_val, new_val, target);
5644 }
5645
5646 /* Expand the __sync_lock_test_and_set intrinsic.  Note that the most
5647    general form is actually an atomic exchange, and some targets only
5648    support a reduced form with the second argument being a constant 1.
5649    EXP is the CALL_EXPR; TARGET is an optional place for us to store
5650    the results.  */
5651
5652 static rtx
5653 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
5654                                   rtx target)
5655 {
5656   rtx val, mem;
5657   enum machine_mode old_mode;
5658
5659   /* Expand the operands.  */
5660   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5661   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5662   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5663      of CONST_INTs, where we know the old_mode only from the call argument.  */
5664   old_mode = GET_MODE (val);
5665   if (old_mode == VOIDmode)
5666     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5667   val = convert_modes (mode, old_mode, val, 1);
5668
5669   return expand_sync_lock_test_and_set (mem, val, target);
5670 }
5671
5672 /* Expand the __sync_synchronize intrinsic.  */
5673
5674 static void
5675 expand_builtin_synchronize (void)
5676 {
5677   gimple x;
5678   VEC (tree, gc) *v_clobbers;
5679
5680 #ifdef HAVE_memory_barrier
5681   if (HAVE_memory_barrier)
5682     {
5683       emit_insn (gen_memory_barrier ());
5684       return;
5685     }
5686 #endif
5687
5688   if (synchronize_libfunc != NULL_RTX)
5689     {
5690       emit_library_call (synchronize_libfunc, LCT_NORMAL, VOIDmode, 0);
5691       return;
5692     }
5693
5694   /* If no explicit memory barrier instruction is available, create an
5695      empty asm stmt with a memory clobber.  */
5696   v_clobbers = VEC_alloc (tree, gc, 1);
5697   VEC_quick_push (tree, v_clobbers,
5698                   tree_cons (NULL, build_string (6, "memory"), NULL));
5699   x = gimple_build_asm_vec ("", NULL, NULL, v_clobbers, NULL);
5700   gimple_asm_set_volatile (x, true);
5701   expand_asm_stmt (x);
5702 }
5703
5704 /* Expand the __sync_lock_release intrinsic.  EXP is the CALL_EXPR.  */
5705
5706 static void
5707 expand_builtin_lock_release (enum machine_mode mode, tree exp)
5708 {
5709   struct expand_operand ops[2];
5710   enum insn_code icode;
5711   rtx mem;
5712
5713   /* Expand the operands.  */
5714   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5715
5716   /* If there is an explicit operation in the md file, use it.  */
5717   icode = direct_optab_handler (sync_lock_release_optab, mode);
5718   if (icode != CODE_FOR_nothing)
5719     {
5720       create_fixed_operand (&ops[0], mem);
5721       create_input_operand (&ops[1], const0_rtx, mode);
5722       if (maybe_expand_insn (icode, 2, ops))
5723         return;
5724     }
5725
5726   /* Otherwise we can implement this operation by emitting a barrier
5727      followed by a store of zero.  */
5728   expand_builtin_synchronize ();
5729   emit_move_insn (mem, const0_rtx);
5730 }
5731 \f
5732 /* Expand an expression EXP that calls a built-in function,
5733    with result going to TARGET if that's convenient
5734    (and in mode MODE if that's convenient).
5735    SUBTARGET may be used as the target for computing one of EXP's operands.
5736    IGNORE is nonzero if the value is to be ignored.  */
5737
5738 rtx
5739 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5740                 int ignore)
5741 {
5742   tree fndecl = get_callee_fndecl (exp);
5743   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5744   enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5745   int flags;
5746
5747   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5748     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5749
5750   /* When not optimizing, generate calls to library functions for a certain
5751      set of builtins.  */
5752   if (!optimize
5753       && !called_as_built_in (fndecl)
5754       && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5755       && fcode != BUILT_IN_ALLOCA
5756       && fcode != BUILT_IN_FREE)
5757     return expand_call (exp, target, ignore);
5758
5759   /* The built-in function expanders test for target == const0_rtx
5760      to determine whether the function's result will be ignored.  */
5761   if (ignore)
5762     target = const0_rtx;
5763
5764   /* If the result of a pure or const built-in function is ignored, and
5765      none of its arguments are volatile, we can avoid expanding the
5766      built-in call and just evaluate the arguments for side-effects.  */
5767   if (target == const0_rtx
5768       && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5769       && !(flags & ECF_LOOPING_CONST_OR_PURE))
5770     {
5771       bool volatilep = false;
5772       tree arg;
5773       call_expr_arg_iterator iter;
5774
5775       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5776         if (TREE_THIS_VOLATILE (arg))
5777           {
5778             volatilep = true;
5779             break;
5780           }
5781
5782       if (! volatilep)
5783         {
5784           FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5785             expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5786           return const0_rtx;
5787         }
5788     }
5789
5790   switch (fcode)
5791     {
5792     CASE_FLT_FN (BUILT_IN_FABS):
5793       target = expand_builtin_fabs (exp, target, subtarget);
5794       if (target)
5795         return target;
5796       break;
5797
5798     CASE_FLT_FN (BUILT_IN_COPYSIGN):
5799       target = expand_builtin_copysign (exp, target, subtarget);
5800       if (target)
5801         return target;
5802       break;
5803
5804       /* Just do a normal library call if we were unable to fold
5805          the values.  */
5806     CASE_FLT_FN (BUILT_IN_CABS):
5807       break;
5808
5809     CASE_FLT_FN (BUILT_IN_EXP):
5810     CASE_FLT_FN (BUILT_IN_EXP10):
5811     CASE_FLT_FN (BUILT_IN_POW10):
5812     CASE_FLT_FN (BUILT_IN_EXP2):
5813     CASE_FLT_FN (BUILT_IN_EXPM1):
5814     CASE_FLT_FN (BUILT_IN_LOGB):
5815     CASE_FLT_FN (BUILT_IN_LOG):
5816     CASE_FLT_FN (BUILT_IN_LOG10):
5817     CASE_FLT_FN (BUILT_IN_LOG2):
5818     CASE_FLT_FN (BUILT_IN_LOG1P):
5819     CASE_FLT_FN (BUILT_IN_TAN):
5820     CASE_FLT_FN (BUILT_IN_ASIN):
5821     CASE_FLT_FN (BUILT_IN_ACOS):
5822     CASE_FLT_FN (BUILT_IN_ATAN):
5823     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5824       /* Treat these like sqrt only if unsafe math optimizations are allowed,
5825          because of possible accuracy problems.  */
5826       if (! flag_unsafe_math_optimizations)
5827         break;
5828     CASE_FLT_FN (BUILT_IN_SQRT):
5829     CASE_FLT_FN (BUILT_IN_FLOOR):
5830     CASE_FLT_FN (BUILT_IN_CEIL):
5831     CASE_FLT_FN (BUILT_IN_TRUNC):
5832     CASE_FLT_FN (BUILT_IN_ROUND):
5833     CASE_FLT_FN (BUILT_IN_NEARBYINT):
5834     CASE_FLT_FN (BUILT_IN_RINT):
5835       target = expand_builtin_mathfn (exp, target, subtarget);
5836       if (target)
5837         return target;
5838       break;
5839
5840     CASE_FLT_FN (BUILT_IN_FMA):
5841       target = expand_builtin_mathfn_ternary (exp, target, subtarget);
5842       if (target)
5843         return target;
5844       break;
5845
5846     CASE_FLT_FN (BUILT_IN_ILOGB):
5847       if (! flag_unsafe_math_optimizations)
5848         break;
5849     CASE_FLT_FN (BUILT_IN_ISINF):
5850     CASE_FLT_FN (BUILT_IN_FINITE):
5851     case BUILT_IN_ISFINITE:
5852     case BUILT_IN_ISNORMAL:
5853       target = expand_builtin_interclass_mathfn (exp, target);
5854       if (target)
5855         return target;
5856       break;
5857
5858     CASE_FLT_FN (BUILT_IN_LCEIL):
5859     CASE_FLT_FN (BUILT_IN_LLCEIL):
5860     CASE_FLT_FN (BUILT_IN_LFLOOR):
5861     CASE_FLT_FN (BUILT_IN_LLFLOOR):
5862       target = expand_builtin_int_roundingfn (exp, target);
5863       if (target)
5864         return target;
5865       break;
5866
5867     CASE_FLT_FN (BUILT_IN_LRINT):
5868     CASE_FLT_FN (BUILT_IN_LLRINT):
5869     CASE_FLT_FN (BUILT_IN_LROUND):
5870     CASE_FLT_FN (BUILT_IN_LLROUND):
5871       target = expand_builtin_int_roundingfn_2 (exp, target);
5872       if (target)
5873         return target;
5874       break;
5875
5876     CASE_FLT_FN (BUILT_IN_POW):
5877       target = expand_builtin_pow (exp, target, subtarget);
5878       if (target)
5879         return target;
5880       break;
5881
5882     CASE_FLT_FN (BUILT_IN_POWI):
5883       target = expand_builtin_powi (exp, target);
5884       if (target)
5885         return target;
5886       break;
5887
5888     CASE_FLT_FN (BUILT_IN_ATAN2):
5889     CASE_FLT_FN (BUILT_IN_LDEXP):
5890     CASE_FLT_FN (BUILT_IN_SCALB):
5891     CASE_FLT_FN (BUILT_IN_SCALBN):
5892     CASE_FLT_FN (BUILT_IN_SCALBLN):
5893       if (! flag_unsafe_math_optimizations)
5894         break;
5895
5896     CASE_FLT_FN (BUILT_IN_FMOD):
5897     CASE_FLT_FN (BUILT_IN_REMAINDER):
5898     CASE_FLT_FN (BUILT_IN_DREM):
5899       target = expand_builtin_mathfn_2 (exp, target, subtarget);
5900       if (target)
5901         return target;
5902       break;
5903
5904     CASE_FLT_FN (BUILT_IN_CEXPI):
5905       target = expand_builtin_cexpi (exp, target);
5906       gcc_assert (target);
5907       return target;
5908
5909     CASE_FLT_FN (BUILT_IN_SIN):
5910     CASE_FLT_FN (BUILT_IN_COS):
5911       if (! flag_unsafe_math_optimizations)
5912         break;
5913       target = expand_builtin_mathfn_3 (exp, target, subtarget);
5914       if (target)
5915         return target;
5916       break;
5917
5918     CASE_FLT_FN (BUILT_IN_SINCOS):
5919       if (! flag_unsafe_math_optimizations)
5920         break;
5921       target = expand_builtin_sincos (exp);
5922       if (target)
5923         return target;
5924       break;
5925
5926     case BUILT_IN_APPLY_ARGS:
5927       return expand_builtin_apply_args ();
5928
5929       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5930          FUNCTION with a copy of the parameters described by
5931          ARGUMENTS, and ARGSIZE.  It returns a block of memory
5932          allocated on the stack into which is stored all the registers
5933          that might possibly be used for returning the result of a
5934          function.  ARGUMENTS is the value returned by
5935          __builtin_apply_args.  ARGSIZE is the number of bytes of
5936          arguments that must be copied.  ??? How should this value be
5937          computed?  We'll also need a safe worst case value for varargs
5938          functions.  */
5939     case BUILT_IN_APPLY:
5940       if (!validate_arglist (exp, POINTER_TYPE,
5941                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5942           && !validate_arglist (exp, REFERENCE_TYPE,
5943                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5944         return const0_rtx;
5945       else
5946         {
5947           rtx ops[3];
5948
5949           ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
5950           ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
5951           ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
5952
5953           return expand_builtin_apply (ops[0], ops[1], ops[2]);
5954         }
5955
5956       /* __builtin_return (RESULT) causes the function to return the
5957          value described by RESULT.  RESULT is address of the block of
5958          memory returned by __builtin_apply.  */
5959     case BUILT_IN_RETURN:
5960       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5961         expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
5962       return const0_rtx;
5963
5964     case BUILT_IN_SAVEREGS:
5965       return expand_builtin_saveregs ();
5966
5967     case BUILT_IN_VA_ARG_PACK:
5968       /* All valid uses of __builtin_va_arg_pack () are removed during
5969          inlining.  */
5970       error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
5971       return const0_rtx;
5972
5973     case BUILT_IN_VA_ARG_PACK_LEN:
5974       /* All valid uses of __builtin_va_arg_pack_len () are removed during
5975          inlining.  */
5976       error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
5977       return const0_rtx;
5978
5979       /* Return the address of the first anonymous stack arg.  */
5980     case BUILT_IN_NEXT_ARG:
5981       if (fold_builtin_next_arg (exp, false))
5982         return const0_rtx;
5983       return expand_builtin_next_arg ();
5984
5985     case BUILT_IN_CLEAR_CACHE:
5986       target = expand_builtin___clear_cache (exp);
5987       if (target)
5988         return target;
5989       break;
5990
5991     case BUILT_IN_CLASSIFY_TYPE:
5992       return expand_builtin_classify_type (exp);
5993
5994     case BUILT_IN_CONSTANT_P:
5995       return const0_rtx;
5996
5997     case BUILT_IN_FRAME_ADDRESS:
5998     case BUILT_IN_RETURN_ADDRESS:
5999       return expand_builtin_frame_address (fndecl, exp);
6000
6001     /* Returns the address of the area where the structure is returned.
6002        0 otherwise.  */
6003     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
6004       if (call_expr_nargs (exp) != 0
6005           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
6006           || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
6007         return const0_rtx;
6008       else
6009         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6010
6011     case BUILT_IN_ALLOCA:
6012       /* If the allocation stems from the declaration of a variable-sized
6013          object, it cannot accumulate.  */
6014       target = expand_builtin_alloca (exp, ALLOCA_FOR_VAR_P (exp));
6015       if (target)
6016         return target;
6017       break;
6018
6019     case BUILT_IN_STACK_SAVE:
6020       return expand_stack_save ();
6021
6022     case BUILT_IN_STACK_RESTORE:
6023       expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6024       return const0_rtx;
6025
6026     case BUILT_IN_BSWAP32:
6027     case BUILT_IN_BSWAP64:
6028       target = expand_builtin_bswap (exp, target, subtarget);
6029
6030       if (target)
6031         return target;
6032       break;
6033
6034     CASE_INT_FN (BUILT_IN_FFS):
6035     case BUILT_IN_FFSIMAX:
6036       target = expand_builtin_unop (target_mode, exp, target,
6037                                     subtarget, ffs_optab);
6038       if (target)
6039         return target;
6040       break;
6041
6042     CASE_INT_FN (BUILT_IN_CLZ):
6043     case BUILT_IN_CLZIMAX:
6044       target = expand_builtin_unop (target_mode, exp, target,
6045                                     subtarget, clz_optab);
6046       if (target)
6047         return target;
6048       break;
6049
6050     CASE_INT_FN (BUILT_IN_CTZ):
6051     case BUILT_IN_CTZIMAX:
6052       target = expand_builtin_unop (target_mode, exp, target,
6053                                     subtarget, ctz_optab);
6054       if (target)
6055         return target;
6056       break;
6057
6058     CASE_INT_FN (BUILT_IN_POPCOUNT):
6059     case BUILT_IN_POPCOUNTIMAX:
6060       target = expand_builtin_unop (target_mode, exp, target,
6061                                     subtarget, popcount_optab);
6062       if (target)
6063         return target;
6064       break;
6065
6066     CASE_INT_FN (BUILT_IN_PARITY):
6067     case BUILT_IN_PARITYIMAX:
6068       target = expand_builtin_unop (target_mode, exp, target,
6069                                     subtarget, parity_optab);
6070       if (target)
6071         return target;
6072       break;
6073
6074     case BUILT_IN_STRLEN:
6075       target = expand_builtin_strlen (exp, target, target_mode);
6076       if (target)
6077         return target;
6078       break;
6079
6080     case BUILT_IN_STRCPY:
6081       target = expand_builtin_strcpy (exp, target);
6082       if (target)
6083         return target;
6084       break;
6085
6086     case BUILT_IN_STRNCPY:
6087       target = expand_builtin_strncpy (exp, target);
6088       if (target)
6089         return target;
6090       break;
6091
6092     case BUILT_IN_STPCPY:
6093       target = expand_builtin_stpcpy (exp, target, mode);
6094       if (target)
6095         return target;
6096       break;
6097
6098     case BUILT_IN_MEMCPY:
6099       target = expand_builtin_memcpy (exp, target);
6100       if (target)
6101         return target;
6102       break;
6103
6104     case BUILT_IN_MEMPCPY:
6105       target = expand_builtin_mempcpy (exp, target, mode);
6106       if (target)
6107         return target;
6108       break;
6109
6110     case BUILT_IN_MEMSET:
6111       target = expand_builtin_memset (exp, target, mode);
6112       if (target)
6113         return target;
6114       break;
6115
6116     case BUILT_IN_BZERO:
6117       target = expand_builtin_bzero (exp);
6118       if (target)
6119         return target;
6120       break;
6121
6122     case BUILT_IN_STRCMP:
6123       target = expand_builtin_strcmp (exp, target);
6124       if (target)
6125         return target;
6126       break;
6127
6128     case BUILT_IN_STRNCMP:
6129       target = expand_builtin_strncmp (exp, target, mode);
6130       if (target)
6131         return target;
6132       break;
6133
6134     case BUILT_IN_BCMP:
6135     case BUILT_IN_MEMCMP:
6136       target = expand_builtin_memcmp (exp, target, mode);
6137       if (target)
6138         return target;
6139       break;
6140
6141     case BUILT_IN_SETJMP:
6142       /* This should have been lowered to the builtins below.  */
6143       gcc_unreachable ();
6144
6145     case BUILT_IN_SETJMP_SETUP:
6146       /* __builtin_setjmp_setup is passed a pointer to an array of five words
6147           and the receiver label.  */
6148       if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6149         {
6150           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6151                                       VOIDmode, EXPAND_NORMAL);
6152           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6153           rtx label_r = label_rtx (label);
6154
6155           /* This is copied from the handling of non-local gotos.  */
6156           expand_builtin_setjmp_setup (buf_addr, label_r);
6157           nonlocal_goto_handler_labels
6158             = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6159                                  nonlocal_goto_handler_labels);
6160           /* ??? Do not let expand_label treat us as such since we would
6161              not want to be both on the list of non-local labels and on
6162              the list of forced labels.  */
6163           FORCED_LABEL (label) = 0;
6164           return const0_rtx;
6165         }
6166       break;
6167
6168     case BUILT_IN_SETJMP_DISPATCHER:
6169        /* __builtin_setjmp_dispatcher is passed the dispatcher label.  */
6170       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6171         {
6172           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6173           rtx label_r = label_rtx (label);
6174
6175           /* Remove the dispatcher label from the list of non-local labels
6176              since the receiver labels have been added to it above.  */
6177           remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6178           return const0_rtx;
6179         }
6180       break;
6181
6182     case BUILT_IN_SETJMP_RECEIVER:
6183        /* __builtin_setjmp_receiver is passed the receiver label.  */
6184       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6185         {
6186           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6187           rtx label_r = label_rtx (label);
6188
6189           expand_builtin_setjmp_receiver (label_r);
6190           return const0_rtx;
6191         }
6192       break;
6193
6194       /* __builtin_longjmp is passed a pointer to an array of five words.
6195          It's similar to the C library longjmp function but works with
6196          __builtin_setjmp above.  */
6197     case BUILT_IN_LONGJMP:
6198       if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6199         {
6200           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6201                                       VOIDmode, EXPAND_NORMAL);
6202           rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6203
6204           if (value != const1_rtx)
6205             {
6206               error ("%<__builtin_longjmp%> second argument must be 1");
6207               return const0_rtx;
6208             }
6209
6210           expand_builtin_longjmp (buf_addr, value);
6211           return const0_rtx;
6212         }
6213       break;
6214
6215     case BUILT_IN_NONLOCAL_GOTO:
6216       target = expand_builtin_nonlocal_goto (exp);
6217       if (target)
6218         return target;
6219       break;
6220
6221       /* This updates the setjmp buffer that is its argument with the value
6222          of the current stack pointer.  */
6223     case BUILT_IN_UPDATE_SETJMP_BUF:
6224       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6225         {
6226           rtx buf_addr
6227             = expand_normal (CALL_EXPR_ARG (exp, 0));
6228
6229           expand_builtin_update_setjmp_buf (buf_addr);
6230           return const0_rtx;
6231         }
6232       break;
6233
6234     case BUILT_IN_TRAP:
6235       expand_builtin_trap ();
6236       return const0_rtx;
6237
6238     case BUILT_IN_UNREACHABLE:
6239       expand_builtin_unreachable ();
6240       return const0_rtx;
6241
6242     CASE_FLT_FN (BUILT_IN_SIGNBIT):
6243     case BUILT_IN_SIGNBITD32:
6244     case BUILT_IN_SIGNBITD64:
6245     case BUILT_IN_SIGNBITD128:
6246       target = expand_builtin_signbit (exp, target);
6247       if (target)
6248         return target;
6249       break;
6250
6251       /* Various hooks for the DWARF 2 __throw routine.  */
6252     case BUILT_IN_UNWIND_INIT:
6253       expand_builtin_unwind_init ();
6254       return const0_rtx;
6255     case BUILT_IN_DWARF_CFA:
6256       return virtual_cfa_rtx;
6257 #ifdef DWARF2_UNWIND_INFO
6258     case BUILT_IN_DWARF_SP_COLUMN:
6259       return expand_builtin_dwarf_sp_column ();
6260     case BUILT_IN_INIT_DWARF_REG_SIZES:
6261       expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6262       return const0_rtx;
6263 #endif
6264     case BUILT_IN_FROB_RETURN_ADDR:
6265       return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6266     case BUILT_IN_EXTRACT_RETURN_ADDR:
6267       return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6268     case BUILT_IN_EH_RETURN:
6269       expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6270                                 CALL_EXPR_ARG (exp, 1));
6271       return const0_rtx;
6272 #ifdef EH_RETURN_DATA_REGNO
6273     case BUILT_IN_EH_RETURN_DATA_REGNO:
6274       return expand_builtin_eh_return_data_regno (exp);
6275 #endif
6276     case BUILT_IN_EXTEND_POINTER:
6277       return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6278     case BUILT_IN_EH_POINTER:
6279       return expand_builtin_eh_pointer (exp);
6280     case BUILT_IN_EH_FILTER:
6281       return expand_builtin_eh_filter (exp);
6282     case BUILT_IN_EH_COPY_VALUES:
6283       return expand_builtin_eh_copy_values (exp);
6284
6285     case BUILT_IN_VA_START:
6286       return expand_builtin_va_start (exp);
6287     case BUILT_IN_VA_END:
6288       return expand_builtin_va_end (exp);
6289     case BUILT_IN_VA_COPY:
6290       return expand_builtin_va_copy (exp);
6291     case BUILT_IN_EXPECT:
6292       return expand_builtin_expect (exp, target);
6293     case BUILT_IN_PREFETCH:
6294       expand_builtin_prefetch (exp);
6295       return const0_rtx;
6296
6297     case BUILT_IN_INIT_TRAMPOLINE:
6298       return expand_builtin_init_trampoline (exp);
6299     case BUILT_IN_ADJUST_TRAMPOLINE:
6300       return expand_builtin_adjust_trampoline (exp);
6301
6302     case BUILT_IN_FORK:
6303     case BUILT_IN_EXECL:
6304     case BUILT_IN_EXECV:
6305     case BUILT_IN_EXECLP:
6306     case BUILT_IN_EXECLE:
6307     case BUILT_IN_EXECVP:
6308     case BUILT_IN_EXECVE:
6309       target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6310       if (target)
6311         return target;
6312       break;
6313
6314     case BUILT_IN_FETCH_AND_ADD_1:
6315     case BUILT_IN_FETCH_AND_ADD_2:
6316     case BUILT_IN_FETCH_AND_ADD_4:
6317     case BUILT_IN_FETCH_AND_ADD_8:
6318     case BUILT_IN_FETCH_AND_ADD_16:
6319       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6320       target = expand_builtin_sync_operation (mode, exp, PLUS,
6321                                               false, target, ignore);
6322       if (target)
6323         return target;
6324       break;
6325
6326     case BUILT_IN_FETCH_AND_SUB_1:
6327     case BUILT_IN_FETCH_AND_SUB_2:
6328     case BUILT_IN_FETCH_AND_SUB_4:
6329     case BUILT_IN_FETCH_AND_SUB_8:
6330     case BUILT_IN_FETCH_AND_SUB_16:
6331       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6332       target = expand_builtin_sync_operation (mode, exp, MINUS,
6333                                               false, target, ignore);
6334       if (target)
6335         return target;
6336       break;
6337
6338     case BUILT_IN_FETCH_AND_OR_1:
6339     case BUILT_IN_FETCH_AND_OR_2:
6340     case BUILT_IN_FETCH_AND_OR_4:
6341     case BUILT_IN_FETCH_AND_OR_8:
6342     case BUILT_IN_FETCH_AND_OR_16:
6343       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6344       target = expand_builtin_sync_operation (mode, exp, IOR,
6345                                               false, target, ignore);
6346       if (target)
6347         return target;
6348       break;
6349
6350     case BUILT_IN_FETCH_AND_AND_1:
6351     case BUILT_IN_FETCH_AND_AND_2:
6352     case BUILT_IN_FETCH_AND_AND_4:
6353     case BUILT_IN_FETCH_AND_AND_8:
6354     case BUILT_IN_FETCH_AND_AND_16:
6355       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6356       target = expand_builtin_sync_operation (mode, exp, AND,
6357                                               false, target, ignore);
6358       if (target)
6359         return target;
6360       break;
6361
6362     case BUILT_IN_FETCH_AND_XOR_1:
6363     case BUILT_IN_FETCH_AND_XOR_2:
6364     case BUILT_IN_FETCH_AND_XOR_4:
6365     case BUILT_IN_FETCH_AND_XOR_8:
6366     case BUILT_IN_FETCH_AND_XOR_16:
6367       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6368       target = expand_builtin_sync_operation (mode, exp, XOR,
6369                                               false, target, ignore);
6370       if (target)
6371         return target;
6372       break;
6373
6374     case BUILT_IN_FETCH_AND_NAND_1:
6375     case BUILT_IN_FETCH_AND_NAND_2:
6376     case BUILT_IN_FETCH_AND_NAND_4:
6377     case BUILT_IN_FETCH_AND_NAND_8:
6378     case BUILT_IN_FETCH_AND_NAND_16:
6379       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6380       target = expand_builtin_sync_operation (mode, exp, NOT,
6381                                               false, target, ignore);
6382       if (target)
6383         return target;
6384       break;
6385
6386     case BUILT_IN_ADD_AND_FETCH_1:
6387     case BUILT_IN_ADD_AND_FETCH_2:
6388     case BUILT_IN_ADD_AND_FETCH_4:
6389     case BUILT_IN_ADD_AND_FETCH_8:
6390     case BUILT_IN_ADD_AND_FETCH_16:
6391       mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6392       target = expand_builtin_sync_operation (mode, exp, PLUS,
6393                                               true, target, ignore);
6394       if (target)
6395         return target;
6396       break;
6397
6398     case BUILT_IN_SUB_AND_FETCH_1:
6399     case BUILT_IN_SUB_AND_FETCH_2:
6400     case BUILT_IN_SUB_AND_FETCH_4:
6401     case BUILT_IN_SUB_AND_FETCH_8:
6402     case BUILT_IN_SUB_AND_FETCH_16:
6403       mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6404       target = expand_builtin_sync_operation (mode, exp, MINUS,
6405                                               true, target, ignore);
6406       if (target)
6407         return target;
6408       break;
6409
6410     case BUILT_IN_OR_AND_FETCH_1:
6411     case BUILT_IN_OR_AND_FETCH_2:
6412     case BUILT_IN_OR_AND_FETCH_4:
6413     case BUILT_IN_OR_AND_FETCH_8:
6414     case BUILT_IN_OR_AND_FETCH_16:
6415       mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6416       target = expand_builtin_sync_operation (mode, exp, IOR,
6417                                               true, target, ignore);
6418       if (target)
6419         return target;
6420       break;
6421
6422     case BUILT_IN_AND_AND_FETCH_1:
6423     case BUILT_IN_AND_AND_FETCH_2:
6424     case BUILT_IN_AND_AND_FETCH_4:
6425     case BUILT_IN_AND_AND_FETCH_8:
6426     case BUILT_IN_AND_AND_FETCH_16:
6427       mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6428       target = expand_builtin_sync_operation (mode, exp, AND,
6429                                               true, target, ignore);
6430       if (target)
6431         return target;
6432       break;
6433
6434     case BUILT_IN_XOR_AND_FETCH_1:
6435     case BUILT_IN_XOR_AND_FETCH_2:
6436     case BUILT_IN_XOR_AND_FETCH_4:
6437     case BUILT_IN_XOR_AND_FETCH_8:
6438     case BUILT_IN_XOR_AND_FETCH_16:
6439       mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6440       target = expand_builtin_sync_operation (mode, exp, XOR,
6441                                               true, target, ignore);
6442       if (target)
6443         return target;
6444       break;
6445
6446     case BUILT_IN_NAND_AND_FETCH_1:
6447     case BUILT_IN_NAND_AND_FETCH_2:
6448     case BUILT_IN_NAND_AND_FETCH_4:
6449     case BUILT_IN_NAND_AND_FETCH_8:
6450     case BUILT_IN_NAND_AND_FETCH_16:
6451       mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6452       target = expand_builtin_sync_operation (mode, exp, NOT,
6453                                               true, target, ignore);
6454       if (target)
6455         return target;
6456       break;
6457
6458     case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6459     case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6460     case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6461     case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6462     case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6463       if (mode == VOIDmode)
6464         mode = TYPE_MODE (boolean_type_node);
6465       if (!target || !register_operand (target, mode))
6466         target = gen_reg_rtx (mode);
6467
6468       mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6469       target = expand_builtin_compare_and_swap (mode, exp, true, target);
6470       if (target)
6471         return target;
6472       break;
6473
6474     case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6475     case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6476     case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6477     case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6478     case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6479       mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6480       target = expand_builtin_compare_and_swap (mode, exp, false, target);
6481       if (target)
6482         return target;
6483       break;
6484
6485     case BUILT_IN_LOCK_TEST_AND_SET_1:
6486     case BUILT_IN_LOCK_TEST_AND_SET_2:
6487     case BUILT_IN_LOCK_TEST_AND_SET_4:
6488     case BUILT_IN_LOCK_TEST_AND_SET_8:
6489     case BUILT_IN_LOCK_TEST_AND_SET_16:
6490       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6491       target = expand_builtin_lock_test_and_set (mode, exp, target);
6492       if (target)
6493         return target;
6494       break;
6495
6496     case BUILT_IN_LOCK_RELEASE_1:
6497     case BUILT_IN_LOCK_RELEASE_2:
6498     case BUILT_IN_LOCK_RELEASE_4:
6499     case BUILT_IN_LOCK_RELEASE_8:
6500     case BUILT_IN_LOCK_RELEASE_16:
6501       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6502       expand_builtin_lock_release (mode, exp);
6503       return const0_rtx;
6504
6505     case BUILT_IN_SYNCHRONIZE:
6506       expand_builtin_synchronize ();
6507       return const0_rtx;
6508
6509     case BUILT_IN_OBJECT_SIZE:
6510       return expand_builtin_object_size (exp);
6511
6512     case BUILT_IN_MEMCPY_CHK:
6513     case BUILT_IN_MEMPCPY_CHK:
6514     case BUILT_IN_MEMMOVE_CHK:
6515     case BUILT_IN_MEMSET_CHK:
6516       target = expand_builtin_memory_chk (exp, target, mode, fcode);
6517       if (target)
6518         return target;
6519       break;
6520
6521     case BUILT_IN_STRCPY_CHK:
6522     case BUILT_IN_STPCPY_CHK:
6523     case BUILT_IN_STRNCPY_CHK:
6524     case BUILT_IN_STRCAT_CHK:
6525     case BUILT_IN_STRNCAT_CHK:
6526     case BUILT_IN_SNPRINTF_CHK:
6527     case BUILT_IN_VSNPRINTF_CHK:
6528       maybe_emit_chk_warning (exp, fcode);
6529       break;
6530
6531     case BUILT_IN_SPRINTF_CHK:
6532     case BUILT_IN_VSPRINTF_CHK:
6533       maybe_emit_sprintf_chk_warning (exp, fcode);
6534       break;
6535
6536     case BUILT_IN_FREE:
6537       maybe_emit_free_warning (exp);
6538       break;
6539
6540     default:    /* just do library call, if unknown builtin */
6541       break;
6542     }
6543
6544   /* The switch statement above can drop through to cause the function
6545      to be called normally.  */
6546   return expand_call (exp, target, ignore);
6547 }
6548
6549 /* Determine whether a tree node represents a call to a built-in
6550    function.  If the tree T is a call to a built-in function with
6551    the right number of arguments of the appropriate types, return
6552    the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6553    Otherwise the return value is END_BUILTINS.  */
6554
6555 enum built_in_function
6556 builtin_mathfn_code (const_tree t)
6557 {
6558   const_tree fndecl, arg, parmlist;
6559   const_tree argtype, parmtype;
6560   const_call_expr_arg_iterator iter;
6561
6562   if (TREE_CODE (t) != CALL_EXPR
6563       || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6564     return END_BUILTINS;
6565
6566   fndecl = get_callee_fndecl (t);
6567   if (fndecl == NULL_TREE
6568       || TREE_CODE (fndecl) != FUNCTION_DECL
6569       || ! DECL_BUILT_IN (fndecl)
6570       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6571     return END_BUILTINS;
6572
6573   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6574   init_const_call_expr_arg_iterator (t, &iter);
6575   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6576     {
6577       /* If a function doesn't take a variable number of arguments,
6578          the last element in the list will have type `void'.  */
6579       parmtype = TREE_VALUE (parmlist);
6580       if (VOID_TYPE_P (parmtype))
6581         {
6582           if (more_const_call_expr_args_p (&iter))
6583             return END_BUILTINS;
6584           return DECL_FUNCTION_CODE (fndecl);
6585         }
6586
6587       if (! more_const_call_expr_args_p (&iter))
6588         return END_BUILTINS;
6589
6590       arg = next_const_call_expr_arg (&iter);
6591       argtype = TREE_TYPE (arg);
6592
6593       if (SCALAR_FLOAT_TYPE_P (parmtype))
6594         {
6595           if (! SCALAR_FLOAT_TYPE_P (argtype))
6596             return END_BUILTINS;
6597         }
6598       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6599         {
6600           if (! COMPLEX_FLOAT_TYPE_P (argtype))
6601             return END_BUILTINS;
6602         }
6603       else if (POINTER_TYPE_P (parmtype))
6604         {
6605           if (! POINTER_TYPE_P (argtype))
6606             return END_BUILTINS;
6607         }
6608       else if (INTEGRAL_TYPE_P (parmtype))
6609         {
6610           if (! INTEGRAL_TYPE_P (argtype))
6611             return END_BUILTINS;
6612         }
6613       else
6614         return END_BUILTINS;
6615     }
6616
6617   /* Variable-length argument list.  */
6618   return DECL_FUNCTION_CODE (fndecl);
6619 }
6620
6621 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6622    evaluate to a constant.  */
6623
6624 static tree
6625 fold_builtin_constant_p (tree arg)
6626 {
6627   /* We return 1 for a numeric type that's known to be a constant
6628      value at compile-time or for an aggregate type that's a
6629      literal constant.  */
6630   STRIP_NOPS (arg);
6631
6632   /* If we know this is a constant, emit the constant of one.  */
6633   if (CONSTANT_CLASS_P (arg)
6634       || (TREE_CODE (arg) == CONSTRUCTOR
6635           && TREE_CONSTANT (arg)))
6636     return integer_one_node;
6637   if (TREE_CODE (arg) == ADDR_EXPR)
6638     {
6639        tree op = TREE_OPERAND (arg, 0);
6640        if (TREE_CODE (op) == STRING_CST
6641            || (TREE_CODE (op) == ARRAY_REF
6642                && integer_zerop (TREE_OPERAND (op, 1))
6643                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6644          return integer_one_node;
6645     }
6646
6647   /* If this expression has side effects, show we don't know it to be a
6648      constant.  Likewise if it's a pointer or aggregate type since in
6649      those case we only want literals, since those are only optimized
6650      when generating RTL, not later.
6651      And finally, if we are compiling an initializer, not code, we
6652      need to return a definite result now; there's not going to be any
6653      more optimization done.  */
6654   if (TREE_SIDE_EFFECTS (arg)
6655       || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6656       || POINTER_TYPE_P (TREE_TYPE (arg))
6657       || cfun == 0
6658       || folding_initializer)
6659     return integer_zero_node;
6660
6661   return NULL_TREE;
6662 }
6663
6664 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6665    return it as a truthvalue.  */
6666
6667 static tree
6668 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6669 {
6670   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6671
6672   fn = built_in_decls[BUILT_IN_EXPECT];
6673   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6674   ret_type = TREE_TYPE (TREE_TYPE (fn));
6675   pred_type = TREE_VALUE (arg_types);
6676   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6677
6678   pred = fold_convert_loc (loc, pred_type, pred);
6679   expected = fold_convert_loc (loc, expected_type, expected);
6680   call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6681
6682   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6683                  build_int_cst (ret_type, 0));
6684 }
6685
6686 /* Fold a call to builtin_expect with arguments ARG0 and ARG1.  Return
6687    NULL_TREE if no simplification is possible.  */
6688
6689 static tree
6690 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
6691 {
6692   tree inner, fndecl;
6693   enum tree_code code;
6694
6695   /* If this is a builtin_expect within a builtin_expect keep the
6696      inner one.  See through a comparison against a constant.  It
6697      might have been added to create a thruthvalue.  */
6698   inner = arg0;
6699   if (COMPARISON_CLASS_P (inner)
6700       && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6701     inner = TREE_OPERAND (inner, 0);
6702
6703   if (TREE_CODE (inner) == CALL_EXPR
6704       && (fndecl = get_callee_fndecl (inner))
6705       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6706       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6707     return arg0;
6708
6709   /* Distribute the expected value over short-circuiting operators.
6710      See through the cast from truthvalue_type_node to long.  */
6711   inner = arg0;
6712   while (TREE_CODE (inner) == NOP_EXPR
6713          && INTEGRAL_TYPE_P (TREE_TYPE (inner))
6714          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
6715     inner = TREE_OPERAND (inner, 0);
6716
6717   code = TREE_CODE (inner);
6718   if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6719     {
6720       tree op0 = TREE_OPERAND (inner, 0);
6721       tree op1 = TREE_OPERAND (inner, 1);
6722
6723       op0 = build_builtin_expect_predicate (loc, op0, arg1);
6724       op1 = build_builtin_expect_predicate (loc, op1, arg1);
6725       inner = build2 (code, TREE_TYPE (inner), op0, op1);
6726
6727       return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6728     }
6729
6730   /* If the argument isn't invariant then there's nothing else we can do.  */
6731   if (!TREE_CONSTANT (arg0))
6732     return NULL_TREE;
6733
6734   /* If we expect that a comparison against the argument will fold to
6735      a constant return the constant.  In practice, this means a true
6736      constant or the address of a non-weak symbol.  */
6737   inner = arg0;
6738   STRIP_NOPS (inner);
6739   if (TREE_CODE (inner) == ADDR_EXPR)
6740     {
6741       do
6742         {
6743           inner = TREE_OPERAND (inner, 0);
6744         }
6745       while (TREE_CODE (inner) == COMPONENT_REF
6746              || TREE_CODE (inner) == ARRAY_REF);
6747       if ((TREE_CODE (inner) == VAR_DECL
6748            || TREE_CODE (inner) == FUNCTION_DECL)
6749           && DECL_WEAK (inner))
6750         return NULL_TREE;
6751     }
6752
6753   /* Otherwise, ARG0 already has the proper type for the return value.  */
6754   return arg0;
6755 }
6756
6757 /* Fold a call to __builtin_classify_type with argument ARG.  */
6758
6759 static tree
6760 fold_builtin_classify_type (tree arg)
6761 {
6762   if (arg == 0)
6763     return build_int_cst (NULL_TREE, no_type_class);
6764
6765   return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
6766 }
6767
6768 /* Fold a call to __builtin_strlen with argument ARG.  */
6769
6770 static tree
6771 fold_builtin_strlen (location_t loc, tree type, tree arg)
6772 {
6773   if (!validate_arg (arg, POINTER_TYPE))
6774     return NULL_TREE;
6775   else
6776     {
6777       tree len = c_strlen (arg, 0);
6778
6779       if (len)
6780         return fold_convert_loc (loc, type, len);
6781
6782       return NULL_TREE;
6783     }
6784 }
6785
6786 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
6787
6788 static tree
6789 fold_builtin_inf (location_t loc, tree type, int warn)
6790 {
6791   REAL_VALUE_TYPE real;
6792
6793   /* __builtin_inff is intended to be usable to define INFINITY on all
6794      targets.  If an infinity is not available, INFINITY expands "to a
6795      positive constant of type float that overflows at translation
6796      time", footnote "In this case, using INFINITY will violate the
6797      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6798      Thus we pedwarn to ensure this constraint violation is
6799      diagnosed.  */
6800   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6801     pedwarn (loc, 0, "target format does not support infinity");
6802
6803   real_inf (&real);
6804   return build_real (type, real);
6805 }
6806
6807 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG.  */
6808
6809 static tree
6810 fold_builtin_nan (tree arg, tree type, int quiet)
6811 {
6812   REAL_VALUE_TYPE real;
6813   const char *str;
6814
6815   if (!validate_arg (arg, POINTER_TYPE))
6816     return NULL_TREE;
6817   str = c_getstr (arg);
6818   if (!str)
6819     return NULL_TREE;
6820
6821   if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
6822     return NULL_TREE;
6823
6824   return build_real (type, real);
6825 }
6826
6827 /* Return true if the floating point expression T has an integer value.
6828    We also allow +Inf, -Inf and NaN to be considered integer values.  */
6829
6830 static bool
6831 integer_valued_real_p (tree t)
6832 {
6833   switch (TREE_CODE (t))
6834     {
6835     case FLOAT_EXPR:
6836       return true;
6837
6838     case ABS_EXPR:
6839     case SAVE_EXPR:
6840       return integer_valued_real_p (TREE_OPERAND (t, 0));
6841
6842     case COMPOUND_EXPR:
6843     case MODIFY_EXPR:
6844     case BIND_EXPR:
6845       return integer_valued_real_p (TREE_OPERAND (t, 1));
6846
6847     case PLUS_EXPR:
6848     case MINUS_EXPR:
6849     case MULT_EXPR:
6850     case MIN_EXPR:
6851     case MAX_EXPR:
6852       return integer_valued_real_p (TREE_OPERAND (t, 0))
6853              && integer_valued_real_p (TREE_OPERAND (t, 1));
6854
6855     case COND_EXPR:
6856       return integer_valued_real_p (TREE_OPERAND (t, 1))
6857              && integer_valued_real_p (TREE_OPERAND (t, 2));
6858
6859     case REAL_CST:
6860       return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
6861
6862     case NOP_EXPR:
6863       {
6864         tree type = TREE_TYPE (TREE_OPERAND (t, 0));
6865         if (TREE_CODE (type) == INTEGER_TYPE)
6866           return true;
6867         if (TREE_CODE (type) == REAL_TYPE)
6868           return integer_valued_real_p (TREE_OPERAND (t, 0));
6869         break;
6870       }
6871
6872     case CALL_EXPR:
6873       switch (builtin_mathfn_code (t))
6874         {
6875         CASE_FLT_FN (BUILT_IN_CEIL):
6876         CASE_FLT_FN (BUILT_IN_FLOOR):
6877         CASE_FLT_FN (BUILT_IN_NEARBYINT):
6878         CASE_FLT_FN (BUILT_IN_RINT):
6879         CASE_FLT_FN (BUILT_IN_ROUND):
6880         CASE_FLT_FN (BUILT_IN_TRUNC):
6881           return true;
6882
6883         CASE_FLT_FN (BUILT_IN_FMIN):
6884         CASE_FLT_FN (BUILT_IN_FMAX):
6885           return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
6886             && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
6887
6888         default:
6889           break;
6890         }
6891       break;
6892
6893     default:
6894       break;
6895     }
6896   return false;
6897 }
6898
6899 /* FNDECL is assumed to be a builtin where truncation can be propagated
6900    across (for instance floor((double)f) == (double)floorf (f).
6901    Do the transformation for a call with argument ARG.  */
6902
6903 static tree
6904 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
6905 {
6906   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6907
6908   if (!validate_arg (arg, REAL_TYPE))
6909     return NULL_TREE;
6910
6911   /* Integer rounding functions are idempotent.  */
6912   if (fcode == builtin_mathfn_code (arg))
6913     return arg;
6914
6915   /* If argument is already integer valued, and we don't need to worry
6916      about setting errno, there's no need to perform rounding.  */
6917   if (! flag_errno_math && integer_valued_real_p (arg))
6918     return arg;
6919
6920   if (optimize)
6921     {
6922       tree arg0 = strip_float_extensions (arg);
6923       tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
6924       tree newtype = TREE_TYPE (arg0);
6925       tree decl;
6926
6927       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6928           && (decl = mathfn_built_in (newtype, fcode)))
6929         return fold_convert_loc (loc, ftype,
6930                                  build_call_expr_loc (loc, decl, 1,
6931                                                   fold_convert_loc (loc,
6932                                                                     newtype,
6933                                                                     arg0)));
6934     }
6935   return NULL_TREE;
6936 }
6937
6938 /* FNDECL is assumed to be builtin which can narrow the FP type of
6939    the argument, for instance lround((double)f) -> lroundf (f).
6940    Do the transformation for a call with argument ARG.  */
6941
6942 static tree
6943 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
6944 {
6945   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6946
6947   if (!validate_arg (arg, REAL_TYPE))
6948     return NULL_TREE;
6949
6950   /* If argument is already integer valued, and we don't need to worry
6951      about setting errno, there's no need to perform rounding.  */
6952   if (! flag_errno_math && integer_valued_real_p (arg))
6953     return fold_build1_loc (loc, FIX_TRUNC_EXPR,
6954                         TREE_TYPE (TREE_TYPE (fndecl)), arg);
6955
6956   if (optimize)
6957     {
6958       tree ftype = TREE_TYPE (arg);
6959       tree arg0 = strip_float_extensions (arg);
6960       tree newtype = TREE_TYPE (arg0);
6961       tree decl;
6962
6963       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6964           && (decl = mathfn_built_in (newtype, fcode)))
6965         return build_call_expr_loc (loc, decl, 1,
6966                                 fold_convert_loc (loc, newtype, arg0));
6967     }
6968
6969   /* Canonicalize llround (x) to lround (x) on LP64 targets where
6970      sizeof (long long) == sizeof (long).  */
6971   if (TYPE_PRECISION (long_long_integer_type_node)
6972       == TYPE_PRECISION (long_integer_type_node))
6973     {
6974       tree newfn = NULL_TREE;
6975       switch (fcode)
6976         {
6977         CASE_FLT_FN (BUILT_IN_LLCEIL):
6978           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
6979           break;
6980
6981         CASE_FLT_FN (BUILT_IN_LLFLOOR):
6982           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
6983           break;
6984
6985         CASE_FLT_FN (BUILT_IN_LLROUND):
6986           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
6987           break;
6988
6989         CASE_FLT_FN (BUILT_IN_LLRINT):
6990           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
6991           break;
6992
6993         default:
6994           break;
6995         }
6996
6997       if (newfn)
6998         {
6999           tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7000           return fold_convert_loc (loc,
7001                                    TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7002         }
7003     }
7004
7005   return NULL_TREE;
7006 }
7007
7008 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG.  TYPE is the
7009    return type.  Return NULL_TREE if no simplification can be made.  */
7010
7011 static tree
7012 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7013 {
7014   tree res;
7015
7016   if (!validate_arg (arg, COMPLEX_TYPE)
7017       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7018     return NULL_TREE;
7019
7020   /* Calculate the result when the argument is a constant.  */
7021   if (TREE_CODE (arg) == COMPLEX_CST
7022       && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7023                               type, mpfr_hypot)))
7024     return res;
7025
7026   if (TREE_CODE (arg) == COMPLEX_EXPR)
7027     {
7028       tree real = TREE_OPERAND (arg, 0);
7029       tree imag = TREE_OPERAND (arg, 1);
7030
7031       /* If either part is zero, cabs is fabs of the other.  */
7032       if (real_zerop (real))
7033         return fold_build1_loc (loc, ABS_EXPR, type, imag);
7034       if (real_zerop (imag))
7035         return fold_build1_loc (loc, ABS_EXPR, type, real);
7036
7037       /* cabs(x+xi) -> fabs(x)*sqrt(2).  */
7038       if (flag_unsafe_math_optimizations
7039           && operand_equal_p (real, imag, OEP_PURE_SAME))
7040         {
7041           const REAL_VALUE_TYPE sqrt2_trunc
7042             = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7043           STRIP_NOPS (real);
7044           return fold_build2_loc (loc, MULT_EXPR, type,
7045                               fold_build1_loc (loc, ABS_EXPR, type, real),
7046                               build_real (type, sqrt2_trunc));
7047         }
7048     }
7049
7050   /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z).  */
7051   if (TREE_CODE (arg) == NEGATE_EXPR
7052       || TREE_CODE (arg) == CONJ_EXPR)
7053     return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7054
7055   /* Don't do this when optimizing for size.  */
7056   if (flag_unsafe_math_optimizations
7057       && optimize && optimize_function_for_speed_p (cfun))
7058     {
7059       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7060
7061       if (sqrtfn != NULL_TREE)
7062         {
7063           tree rpart, ipart, result;
7064
7065           arg = builtin_save_expr (arg);
7066
7067           rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7068           ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7069
7070           rpart = builtin_save_expr (rpart);
7071           ipart = builtin_save_expr (ipart);
7072
7073           result = fold_build2_loc (loc, PLUS_EXPR, type,
7074                                 fold_build2_loc (loc, MULT_EXPR, type,
7075                                              rpart, rpart),
7076                                 fold_build2_loc (loc, MULT_EXPR, type,
7077                                              ipart, ipart));
7078
7079           return build_call_expr_loc (loc, sqrtfn, 1, result);
7080         }
7081     }
7082
7083   return NULL_TREE;
7084 }
7085
7086 /* Build a complex (inf +- 0i) for the result of cproj.  TYPE is the
7087    complex tree type of the result.  If NEG is true, the imaginary
7088    zero is negative.  */
7089
7090 static tree
7091 build_complex_cproj (tree type, bool neg)
7092 {
7093   REAL_VALUE_TYPE rinf, rzero = dconst0;
7094
7095   real_inf (&rinf);
7096   rzero.sign = neg;
7097   return build_complex (type, build_real (TREE_TYPE (type), rinf),
7098                         build_real (TREE_TYPE (type), rzero));
7099 }
7100
7101 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG.  TYPE is the
7102    return type.  Return NULL_TREE if no simplification can be made.  */
7103
7104 static tree
7105 fold_builtin_cproj (location_t loc, tree arg, tree type)
7106 {
7107   if (!validate_arg (arg, COMPLEX_TYPE)
7108       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7109     return NULL_TREE;
7110
7111   /* If there are no infinities, return arg.  */
7112   if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type))))
7113     return non_lvalue_loc (loc, arg);
7114
7115   /* Calculate the result when the argument is a constant.  */
7116   if (TREE_CODE (arg) == COMPLEX_CST)
7117     {
7118       const REAL_VALUE_TYPE *real = TREE_REAL_CST_PTR (TREE_REALPART (arg));
7119       const REAL_VALUE_TYPE *imag = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
7120
7121       if (real_isinf (real) || real_isinf (imag))
7122         return build_complex_cproj (type, imag->sign);
7123       else
7124         return arg;
7125     }
7126   else if (TREE_CODE (arg) == COMPLEX_EXPR)
7127     {
7128       tree real = TREE_OPERAND (arg, 0);
7129       tree imag = TREE_OPERAND (arg, 1);
7130
7131       STRIP_NOPS (real);
7132       STRIP_NOPS (imag);
7133
7134       /* If the real part is inf and the imag part is known to be
7135          nonnegative, return (inf + 0i).  Remember side-effects are
7136          possible in the imag part.  */
7137       if (TREE_CODE (real) == REAL_CST
7138           && real_isinf (TREE_REAL_CST_PTR (real))
7139           && tree_expr_nonnegative_p (imag))
7140         return omit_one_operand_loc (loc, type,
7141                                      build_complex_cproj (type, false),
7142                                      arg);
7143
7144       /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7145          Remember side-effects are possible in the real part.  */
7146       if (TREE_CODE (imag) == REAL_CST
7147           && real_isinf (TREE_REAL_CST_PTR (imag)))
7148         return
7149           omit_one_operand_loc (loc, type,
7150                                 build_complex_cproj (type, TREE_REAL_CST_PTR
7151                                                      (imag)->sign), arg);
7152     }
7153
7154   return NULL_TREE;
7155 }
7156
7157 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7158    Return NULL_TREE if no simplification can be made.  */
7159
7160 static tree
7161 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7162 {
7163
7164   enum built_in_function fcode;
7165   tree res;
7166
7167   if (!validate_arg (arg, REAL_TYPE))
7168     return NULL_TREE;
7169
7170   /* Calculate the result when the argument is a constant.  */
7171   if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7172     return res;
7173
7174   /* Optimize sqrt(expN(x)) = expN(x*0.5).  */
7175   fcode = builtin_mathfn_code (arg);
7176   if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7177     {
7178       tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7179       arg = fold_build2_loc (loc, MULT_EXPR, type,
7180                          CALL_EXPR_ARG (arg, 0),
7181                          build_real (type, dconsthalf));
7182       return build_call_expr_loc (loc, expfn, 1, arg);
7183     }
7184
7185   /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)).  */
7186   if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7187     {
7188       tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7189
7190       if (powfn)
7191         {
7192           tree arg0 = CALL_EXPR_ARG (arg, 0);
7193           tree tree_root;
7194           /* The inner root was either sqrt or cbrt.  */
7195           /* This was a conditional expression but it triggered a bug
7196              in Sun C 5.5.  */
7197           REAL_VALUE_TYPE dconstroot;
7198           if (BUILTIN_SQRT_P (fcode))
7199             dconstroot = dconsthalf;
7200           else
7201             dconstroot = dconst_third ();
7202
7203           /* Adjust for the outer root.  */
7204           SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7205           dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7206           tree_root = build_real (type, dconstroot);
7207           return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7208         }
7209     }
7210
7211   /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5).  */
7212   if (flag_unsafe_math_optimizations
7213       && (fcode == BUILT_IN_POW
7214           || fcode == BUILT_IN_POWF
7215           || fcode == BUILT_IN_POWL))
7216     {
7217       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7218       tree arg0 = CALL_EXPR_ARG (arg, 0);
7219       tree arg1 = CALL_EXPR_ARG (arg, 1);
7220       tree narg1;
7221       if (!tree_expr_nonnegative_p (arg0))
7222         arg0 = build1 (ABS_EXPR, type, arg0);
7223       narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7224                            build_real (type, dconsthalf));
7225       return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7226     }
7227
7228   return NULL_TREE;
7229 }
7230
7231 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7232    Return NULL_TREE if no simplification can be made.  */
7233
7234 static tree
7235 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7236 {
7237   const enum built_in_function fcode = builtin_mathfn_code (arg);
7238   tree res;
7239
7240   if (!validate_arg (arg, REAL_TYPE))
7241     return NULL_TREE;
7242
7243   /* Calculate the result when the argument is a constant.  */
7244   if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7245     return res;
7246
7247   if (flag_unsafe_math_optimizations)
7248     {
7249       /* Optimize cbrt(expN(x)) -> expN(x/3).  */
7250       if (BUILTIN_EXPONENT_P (fcode))
7251         {
7252           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7253           const REAL_VALUE_TYPE third_trunc =
7254             real_value_truncate (TYPE_MODE (type), dconst_third ());
7255           arg = fold_build2_loc (loc, MULT_EXPR, type,
7256                              CALL_EXPR_ARG (arg, 0),
7257                              build_real (type, third_trunc));
7258           return build_call_expr_loc (loc, expfn, 1, arg);
7259         }
7260
7261       /* Optimize cbrt(sqrt(x)) -> pow(x,1/6).  */
7262       if (BUILTIN_SQRT_P (fcode))
7263         {
7264           tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7265
7266           if (powfn)
7267             {
7268               tree arg0 = CALL_EXPR_ARG (arg, 0);
7269               tree tree_root;
7270               REAL_VALUE_TYPE dconstroot = dconst_third ();
7271
7272               SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7273               dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7274               tree_root = build_real (type, dconstroot);
7275               return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7276             }
7277         }
7278
7279       /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative.  */
7280       if (BUILTIN_CBRT_P (fcode))
7281         {
7282           tree arg0 = CALL_EXPR_ARG (arg, 0);
7283           if (tree_expr_nonnegative_p (arg0))
7284             {
7285               tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7286
7287               if (powfn)
7288                 {
7289                   tree tree_root;
7290                   REAL_VALUE_TYPE dconstroot;
7291
7292                   real_arithmetic (&dconstroot, MULT_EXPR,
7293                                    dconst_third_ptr (), dconst_third_ptr ());
7294                   dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7295                   tree_root = build_real (type, dconstroot);
7296                   return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7297                 }
7298             }
7299         }
7300
7301       /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative.  */
7302       if (fcode == BUILT_IN_POW
7303           || fcode == BUILT_IN_POWF
7304           || fcode == BUILT_IN_POWL)
7305         {
7306           tree arg00 = CALL_EXPR_ARG (arg, 0);
7307           tree arg01 = CALL_EXPR_ARG (arg, 1);
7308           if (tree_expr_nonnegative_p (arg00))
7309             {
7310               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7311               const REAL_VALUE_TYPE dconstroot
7312                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7313               tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7314                                          build_real (type, dconstroot));
7315               return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7316             }
7317         }
7318     }
7319   return NULL_TREE;
7320 }
7321
7322 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7323    TYPE is the type of the return value.  Return NULL_TREE if no
7324    simplification can be made.  */
7325
7326 static tree
7327 fold_builtin_cos (location_t loc,
7328                   tree arg, tree type, tree fndecl)
7329 {
7330   tree res, narg;
7331
7332   if (!validate_arg (arg, REAL_TYPE))
7333     return NULL_TREE;
7334
7335   /* Calculate the result when the argument is a constant.  */
7336   if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7337     return res;
7338
7339   /* Optimize cos(-x) into cos (x).  */
7340   if ((narg = fold_strip_sign_ops (arg)))
7341     return build_call_expr_loc (loc, fndecl, 1, narg);
7342
7343   return NULL_TREE;
7344 }
7345
7346 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7347    Return NULL_TREE if no simplification can be made.  */
7348
7349 static tree
7350 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7351 {
7352   if (validate_arg (arg, REAL_TYPE))
7353     {
7354       tree res, narg;
7355
7356       /* Calculate the result when the argument is a constant.  */
7357       if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7358         return res;
7359
7360       /* Optimize cosh(-x) into cosh (x).  */
7361       if ((narg = fold_strip_sign_ops (arg)))
7362         return build_call_expr_loc (loc, fndecl, 1, narg);
7363     }
7364
7365   return NULL_TREE;
7366 }
7367
7368 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7369    argument ARG.  TYPE is the type of the return value.  Return
7370    NULL_TREE if no simplification can be made.  */
7371
7372 static tree
7373 fold_builtin_ccos (location_t loc, tree arg, tree type, tree fndecl,
7374                    bool hyper)
7375 {
7376   if (validate_arg (arg, COMPLEX_TYPE)
7377       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7378     {
7379       tree tmp;
7380
7381       /* Calculate the result when the argument is a constant.  */
7382       if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7383         return tmp;
7384
7385       /* Optimize fn(-x) into fn(x).  */
7386       if ((tmp = fold_strip_sign_ops (arg)))
7387         return build_call_expr_loc (loc, fndecl, 1, tmp);
7388     }
7389
7390   return NULL_TREE;
7391 }
7392
7393 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7394    Return NULL_TREE if no simplification can be made.  */
7395
7396 static tree
7397 fold_builtin_tan (tree arg, tree type)
7398 {
7399   enum built_in_function fcode;
7400   tree res;
7401
7402   if (!validate_arg (arg, REAL_TYPE))
7403     return NULL_TREE;
7404
7405   /* Calculate the result when the argument is a constant.  */
7406   if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7407     return res;
7408
7409   /* Optimize tan(atan(x)) = x.  */
7410   fcode = builtin_mathfn_code (arg);
7411   if (flag_unsafe_math_optimizations
7412       && (fcode == BUILT_IN_ATAN
7413           || fcode == BUILT_IN_ATANF
7414           || fcode == BUILT_IN_ATANL))
7415     return CALL_EXPR_ARG (arg, 0);
7416
7417   return NULL_TREE;
7418 }
7419
7420 /* Fold function call to builtin sincos, sincosf, or sincosl.  Return
7421    NULL_TREE if no simplification can be made.  */
7422
7423 static tree
7424 fold_builtin_sincos (location_t loc,
7425                      tree arg0, tree arg1, tree arg2)
7426 {
7427   tree type;
7428   tree res, fn, call;
7429
7430   if (!validate_arg (arg0, REAL_TYPE)
7431       || !validate_arg (arg1, POINTER_TYPE)
7432       || !validate_arg (arg2, POINTER_TYPE))
7433     return NULL_TREE;
7434
7435   type = TREE_TYPE (arg0);
7436
7437   /* Calculate the result when the argument is a constant.  */
7438   if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7439     return res;
7440
7441   /* Canonicalize sincos to cexpi.  */
7442   if (!TARGET_C99_FUNCTIONS)
7443     return NULL_TREE;
7444   fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7445   if (!fn)
7446     return NULL_TREE;
7447
7448   call = build_call_expr_loc (loc, fn, 1, arg0);
7449   call = builtin_save_expr (call);
7450
7451   return build2 (COMPOUND_EXPR, void_type_node,
7452                  build2 (MODIFY_EXPR, void_type_node,
7453                          build_fold_indirect_ref_loc (loc, arg1),
7454                          build1 (IMAGPART_EXPR, type, call)),
7455                  build2 (MODIFY_EXPR, void_type_node,
7456                          build_fold_indirect_ref_loc (loc, arg2),
7457                          build1 (REALPART_EXPR, type, call)));
7458 }
7459
7460 /* Fold function call to builtin cexp, cexpf, or cexpl.  Return
7461    NULL_TREE if no simplification can be made.  */
7462
7463 static tree
7464 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7465 {
7466   tree rtype;
7467   tree realp, imagp, ifn;
7468   tree res;
7469
7470   if (!validate_arg (arg0, COMPLEX_TYPE)
7471       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7472     return NULL_TREE;
7473
7474   /* Calculate the result when the argument is a constant.  */
7475   if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7476     return res;
7477
7478   rtype = TREE_TYPE (TREE_TYPE (arg0));
7479
7480   /* In case we can figure out the real part of arg0 and it is constant zero
7481      fold to cexpi.  */
7482   if (!TARGET_C99_FUNCTIONS)
7483     return NULL_TREE;
7484   ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7485   if (!ifn)
7486     return NULL_TREE;
7487
7488   if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7489       && real_zerop (realp))
7490     {
7491       tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7492       return build_call_expr_loc (loc, ifn, 1, narg);
7493     }
7494
7495   /* In case we can easily decompose real and imaginary parts split cexp
7496      to exp (r) * cexpi (i).  */
7497   if (flag_unsafe_math_optimizations
7498       && realp)
7499     {
7500       tree rfn, rcall, icall;
7501
7502       rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7503       if (!rfn)
7504         return NULL_TREE;
7505
7506       imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7507       if (!imagp)
7508         return NULL_TREE;
7509
7510       icall = build_call_expr_loc (loc, ifn, 1, imagp);
7511       icall = builtin_save_expr (icall);
7512       rcall = build_call_expr_loc (loc, rfn, 1, realp);
7513       rcall = builtin_save_expr (rcall);
7514       return fold_build2_loc (loc, COMPLEX_EXPR, type,
7515                           fold_build2_loc (loc, MULT_EXPR, rtype,
7516                                        rcall,
7517                                        fold_build1_loc (loc, REALPART_EXPR,
7518                                                     rtype, icall)),
7519                           fold_build2_loc (loc, MULT_EXPR, rtype,
7520                                        rcall,
7521                                        fold_build1_loc (loc, IMAGPART_EXPR,
7522                                                     rtype, icall)));
7523     }
7524
7525   return NULL_TREE;
7526 }
7527
7528 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7529    Return NULL_TREE if no simplification can be made.  */
7530
7531 static tree
7532 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7533 {
7534   if (!validate_arg (arg, REAL_TYPE))
7535     return NULL_TREE;
7536
7537   /* Optimize trunc of constant value.  */
7538   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7539     {
7540       REAL_VALUE_TYPE r, x;
7541       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7542
7543       x = TREE_REAL_CST (arg);
7544       real_trunc (&r, TYPE_MODE (type), &x);
7545       return build_real (type, r);
7546     }
7547
7548   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7549 }
7550
7551 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7552    Return NULL_TREE if no simplification can be made.  */
7553
7554 static tree
7555 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7556 {
7557   if (!validate_arg (arg, REAL_TYPE))
7558     return NULL_TREE;
7559
7560   /* Optimize floor of constant value.  */
7561   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7562     {
7563       REAL_VALUE_TYPE x;
7564
7565       x = TREE_REAL_CST (arg);
7566       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7567         {
7568           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7569           REAL_VALUE_TYPE r;
7570
7571           real_floor (&r, TYPE_MODE (type), &x);
7572           return build_real (type, r);
7573         }
7574     }
7575
7576   /* Fold floor (x) where x is nonnegative to trunc (x).  */
7577   if (tree_expr_nonnegative_p (arg))
7578     {
7579       tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7580       if (truncfn)
7581         return build_call_expr_loc (loc, truncfn, 1, arg);
7582     }
7583
7584   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7585 }
7586
7587 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7588    Return NULL_TREE if no simplification can be made.  */
7589
7590 static tree
7591 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7592 {
7593   if (!validate_arg (arg, REAL_TYPE))
7594     return NULL_TREE;
7595
7596   /* Optimize ceil of constant value.  */
7597   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7598     {
7599       REAL_VALUE_TYPE x;
7600
7601       x = TREE_REAL_CST (arg);
7602       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7603         {
7604           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7605           REAL_VALUE_TYPE r;
7606
7607           real_ceil (&r, TYPE_MODE (type), &x);
7608           return build_real (type, r);
7609         }
7610     }
7611
7612   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7613 }
7614
7615 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7616    Return NULL_TREE if no simplification can be made.  */
7617
7618 static tree
7619 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7620 {
7621   if (!validate_arg (arg, REAL_TYPE))
7622     return NULL_TREE;
7623
7624   /* Optimize round of constant value.  */
7625   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7626     {
7627       REAL_VALUE_TYPE x;
7628
7629       x = TREE_REAL_CST (arg);
7630       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7631         {
7632           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7633           REAL_VALUE_TYPE r;
7634
7635           real_round (&r, TYPE_MODE (type), &x);
7636           return build_real (type, r);
7637         }
7638     }
7639
7640   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7641 }
7642
7643 /* Fold function call to builtin lround, lroundf or lroundl (or the
7644    corresponding long long versions) and other rounding functions.  ARG
7645    is the argument to the call.  Return NULL_TREE if no simplification
7646    can be made.  */
7647
7648 static tree
7649 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7650 {
7651   if (!validate_arg (arg, REAL_TYPE))
7652     return NULL_TREE;
7653
7654   /* Optimize lround of constant value.  */
7655   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7656     {
7657       const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7658
7659       if (real_isfinite (&x))
7660         {
7661           tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7662           tree ftype = TREE_TYPE (arg);
7663           double_int val;
7664           REAL_VALUE_TYPE r;
7665
7666           switch (DECL_FUNCTION_CODE (fndecl))
7667             {
7668             CASE_FLT_FN (BUILT_IN_LFLOOR):
7669             CASE_FLT_FN (BUILT_IN_LLFLOOR):
7670               real_floor (&r, TYPE_MODE (ftype), &x);
7671               break;
7672
7673             CASE_FLT_FN (BUILT_IN_LCEIL):
7674             CASE_FLT_FN (BUILT_IN_LLCEIL):
7675               real_ceil (&r, TYPE_MODE (ftype), &x);
7676               break;
7677
7678             CASE_FLT_FN (BUILT_IN_LROUND):
7679             CASE_FLT_FN (BUILT_IN_LLROUND):
7680               real_round (&r, TYPE_MODE (ftype), &x);
7681               break;
7682
7683             default:
7684               gcc_unreachable ();
7685             }
7686
7687           real_to_integer2 ((HOST_WIDE_INT *)&val.low, &val.high, &r);
7688           if (double_int_fits_to_tree_p (itype, val))
7689             return double_int_to_tree (itype, val);
7690         }
7691     }
7692
7693   switch (DECL_FUNCTION_CODE (fndecl))
7694     {
7695     CASE_FLT_FN (BUILT_IN_LFLOOR):
7696     CASE_FLT_FN (BUILT_IN_LLFLOOR):
7697       /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x).  */
7698       if (tree_expr_nonnegative_p (arg))
7699         return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7700                             TREE_TYPE (TREE_TYPE (fndecl)), arg);
7701       break;
7702     default:;
7703     }
7704
7705   return fold_fixed_mathfn (loc, fndecl, arg);
7706 }
7707
7708 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7709    and their long and long long variants (i.e. ffsl and ffsll).  ARG is
7710    the argument to the call.  Return NULL_TREE if no simplification can
7711    be made.  */
7712
7713 static tree
7714 fold_builtin_bitop (tree fndecl, tree arg)
7715 {
7716   if (!validate_arg (arg, INTEGER_TYPE))
7717     return NULL_TREE;
7718
7719   /* Optimize for constant argument.  */
7720   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7721     {
7722       HOST_WIDE_INT hi, width, result;
7723       unsigned HOST_WIDE_INT lo;
7724       tree type;
7725
7726       type = TREE_TYPE (arg);
7727       width = TYPE_PRECISION (type);
7728       lo = TREE_INT_CST_LOW (arg);
7729
7730       /* Clear all the bits that are beyond the type's precision.  */
7731       if (width > HOST_BITS_PER_WIDE_INT)
7732         {
7733           hi = TREE_INT_CST_HIGH (arg);
7734           if (width < 2 * HOST_BITS_PER_WIDE_INT)
7735             hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7736         }
7737       else
7738         {
7739           hi = 0;
7740           if (width < HOST_BITS_PER_WIDE_INT)
7741             lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7742         }
7743
7744       switch (DECL_FUNCTION_CODE (fndecl))
7745         {
7746         CASE_INT_FN (BUILT_IN_FFS):
7747           if (lo != 0)
7748             result = ffs_hwi (lo);
7749           else if (hi != 0)
7750             result = HOST_BITS_PER_WIDE_INT + ffs_hwi (hi);
7751           else
7752             result = 0;
7753           break;
7754
7755         CASE_INT_FN (BUILT_IN_CLZ):
7756           if (hi != 0)
7757             result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7758           else if (lo != 0)
7759             result = width - floor_log2 (lo) - 1;
7760           else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7761             result = width;
7762           break;
7763
7764         CASE_INT_FN (BUILT_IN_CTZ):
7765           if (lo != 0)
7766             result = ctz_hwi (lo);
7767           else if (hi != 0)
7768             result = HOST_BITS_PER_WIDE_INT + ctz_hwi (hi);
7769           else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7770             result = width;
7771           break;
7772
7773         CASE_INT_FN (BUILT_IN_POPCOUNT):
7774           result = 0;
7775           while (lo)
7776             result++, lo &= lo - 1;
7777           while (hi)
7778             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7779           break;
7780
7781         CASE_INT_FN (BUILT_IN_PARITY):
7782           result = 0;
7783           while (lo)
7784             result++, lo &= lo - 1;
7785           while (hi)
7786             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7787           result &= 1;
7788           break;
7789
7790         default:
7791           gcc_unreachable ();
7792         }
7793
7794       return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7795     }
7796
7797   return NULL_TREE;
7798 }
7799
7800 /* Fold function call to builtin_bswap and the long and long long
7801    variants.  Return NULL_TREE if no simplification can be made.  */
7802 static tree
7803 fold_builtin_bswap (tree fndecl, tree arg)
7804 {
7805   if (! validate_arg (arg, INTEGER_TYPE))
7806     return NULL_TREE;
7807
7808   /* Optimize constant value.  */
7809   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7810     {
7811       HOST_WIDE_INT hi, width, r_hi = 0;
7812       unsigned HOST_WIDE_INT lo, r_lo = 0;
7813       tree type;
7814
7815       type = TREE_TYPE (arg);
7816       width = TYPE_PRECISION (type);
7817       lo = TREE_INT_CST_LOW (arg);
7818       hi = TREE_INT_CST_HIGH (arg);
7819
7820       switch (DECL_FUNCTION_CODE (fndecl))
7821         {
7822           case BUILT_IN_BSWAP32:
7823           case BUILT_IN_BSWAP64:
7824             {
7825               int s;
7826
7827               for (s = 0; s < width; s += 8)
7828                 {
7829                   int d = width - s - 8;
7830                   unsigned HOST_WIDE_INT byte;
7831
7832                   if (s < HOST_BITS_PER_WIDE_INT)
7833                     byte = (lo >> s) & 0xff;
7834                   else
7835                     byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
7836
7837                   if (d < HOST_BITS_PER_WIDE_INT)
7838                     r_lo |= byte << d;
7839                   else
7840                     r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
7841                 }
7842             }
7843
7844             break;
7845
7846         default:
7847           gcc_unreachable ();
7848         }
7849
7850       if (width < HOST_BITS_PER_WIDE_INT)
7851         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
7852       else
7853         return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
7854     }
7855
7856   return NULL_TREE;
7857 }
7858
7859 /* A subroutine of fold_builtin to fold the various logarithmic
7860    functions.  Return NULL_TREE if no simplification can me made.
7861    FUNC is the corresponding MPFR logarithm function.  */
7862
7863 static tree
7864 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
7865                         int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
7866 {
7867   if (validate_arg (arg, REAL_TYPE))
7868     {
7869       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7870       tree res;
7871       const enum built_in_function fcode = builtin_mathfn_code (arg);
7872
7873       /* Calculate the result when the argument is a constant.  */
7874       if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
7875         return res;
7876
7877       /* Special case, optimize logN(expN(x)) = x.  */
7878       if (flag_unsafe_math_optimizations
7879           && ((func == mpfr_log
7880                && (fcode == BUILT_IN_EXP
7881                    || fcode == BUILT_IN_EXPF
7882                    || fcode == BUILT_IN_EXPL))
7883               || (func == mpfr_log2
7884                   && (fcode == BUILT_IN_EXP2
7885                       || fcode == BUILT_IN_EXP2F
7886                       || fcode == BUILT_IN_EXP2L))
7887               || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
7888         return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
7889
7890       /* Optimize logN(func()) for various exponential functions.  We
7891          want to determine the value "x" and the power "exponent" in
7892          order to transform logN(x**exponent) into exponent*logN(x).  */
7893       if (flag_unsafe_math_optimizations)
7894         {
7895           tree exponent = 0, x = 0;
7896
7897           switch (fcode)
7898           {
7899           CASE_FLT_FN (BUILT_IN_EXP):
7900             /* Prepare to do logN(exp(exponent) -> exponent*logN(e).  */
7901             x = build_real (type, real_value_truncate (TYPE_MODE (type),
7902                                                        dconst_e ()));
7903             exponent = CALL_EXPR_ARG (arg, 0);
7904             break;
7905           CASE_FLT_FN (BUILT_IN_EXP2):
7906             /* Prepare to do logN(exp2(exponent) -> exponent*logN(2).  */
7907             x = build_real (type, dconst2);
7908             exponent = CALL_EXPR_ARG (arg, 0);
7909             break;
7910           CASE_FLT_FN (BUILT_IN_EXP10):
7911           CASE_FLT_FN (BUILT_IN_POW10):
7912             /* Prepare to do logN(exp10(exponent) -> exponent*logN(10).  */
7913             {
7914               REAL_VALUE_TYPE dconst10;
7915               real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
7916               x = build_real (type, dconst10);
7917             }
7918             exponent = CALL_EXPR_ARG (arg, 0);
7919             break;
7920           CASE_FLT_FN (BUILT_IN_SQRT):
7921             /* Prepare to do logN(sqrt(x) -> 0.5*logN(x).  */
7922             x = CALL_EXPR_ARG (arg, 0);
7923             exponent = build_real (type, dconsthalf);
7924             break;
7925           CASE_FLT_FN (BUILT_IN_CBRT):
7926             /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x).  */
7927             x = CALL_EXPR_ARG (arg, 0);
7928             exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
7929                                                               dconst_third ()));
7930             break;
7931           CASE_FLT_FN (BUILT_IN_POW):
7932             /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x).  */
7933             x = CALL_EXPR_ARG (arg, 0);
7934             exponent = CALL_EXPR_ARG (arg, 1);
7935             break;
7936           default:
7937             break;
7938           }
7939
7940           /* Now perform the optimization.  */
7941           if (x && exponent)
7942             {
7943               tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
7944               return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
7945             }
7946         }
7947     }
7948
7949   return NULL_TREE;
7950 }
7951
7952 /* Fold a builtin function call to hypot, hypotf, or hypotl.  Return
7953    NULL_TREE if no simplification can be made.  */
7954
7955 static tree
7956 fold_builtin_hypot (location_t loc, tree fndecl,
7957                     tree arg0, tree arg1, tree type)
7958 {
7959   tree res, narg0, narg1;
7960
7961   if (!validate_arg (arg0, REAL_TYPE)
7962       || !validate_arg (arg1, REAL_TYPE))
7963     return NULL_TREE;
7964
7965   /* Calculate the result when the argument is a constant.  */
7966   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
7967     return res;
7968
7969   /* If either argument to hypot has a negate or abs, strip that off.
7970      E.g. hypot(-x,fabs(y)) -> hypot(x,y).  */
7971   narg0 = fold_strip_sign_ops (arg0);
7972   narg1 = fold_strip_sign_ops (arg1);
7973   if (narg0 || narg1)
7974     {
7975       return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
7976                               narg1 ? narg1 : arg1);
7977     }
7978
7979   /* If either argument is zero, hypot is fabs of the other.  */
7980   if (real_zerop (arg0))
7981     return fold_build1_loc (loc, ABS_EXPR, type, arg1);
7982   else if (real_zerop (arg1))
7983     return fold_build1_loc (loc, ABS_EXPR, type, arg0);
7984
7985   /* hypot(x,x) -> fabs(x)*sqrt(2).  */
7986   if (flag_unsafe_math_optimizations
7987       && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
7988     {
7989       const REAL_VALUE_TYPE sqrt2_trunc
7990         = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7991       return fold_build2_loc (loc, MULT_EXPR, type,
7992                           fold_build1_loc (loc, ABS_EXPR, type, arg0),
7993                           build_real (type, sqrt2_trunc));
7994     }
7995
7996   return NULL_TREE;
7997 }
7998
7999
8000 /* Fold a builtin function call to pow, powf, or powl.  Return
8001    NULL_TREE if no simplification can be made.  */
8002 static tree
8003 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
8004 {
8005   tree res;
8006
8007   if (!validate_arg (arg0, REAL_TYPE)
8008        || !validate_arg (arg1, REAL_TYPE))
8009     return NULL_TREE;
8010
8011   /* Calculate the result when the argument is a constant.  */
8012   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8013     return res;
8014
8015   /* Optimize pow(1.0,y) = 1.0.  */
8016   if (real_onep (arg0))
8017     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8018
8019   if (TREE_CODE (arg1) == REAL_CST
8020       && !TREE_OVERFLOW (arg1))
8021     {
8022       REAL_VALUE_TYPE cint;
8023       REAL_VALUE_TYPE c;
8024       HOST_WIDE_INT n;
8025
8026       c = TREE_REAL_CST (arg1);
8027
8028       /* Optimize pow(x,0.0) = 1.0.  */
8029       if (REAL_VALUES_EQUAL (c, dconst0))
8030         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8031                                  arg0);
8032
8033       /* Optimize pow(x,1.0) = x.  */
8034       if (REAL_VALUES_EQUAL (c, dconst1))
8035         return arg0;
8036
8037       /* Optimize pow(x,-1.0) = 1.0/x.  */
8038       if (REAL_VALUES_EQUAL (c, dconstm1))
8039         return fold_build2_loc (loc, RDIV_EXPR, type,
8040                             build_real (type, dconst1), arg0);
8041
8042       /* Optimize pow(x,0.5) = sqrt(x).  */
8043       if (flag_unsafe_math_optimizations
8044           && REAL_VALUES_EQUAL (c, dconsthalf))
8045         {
8046           tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8047
8048           if (sqrtfn != NULL_TREE)
8049             return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8050         }
8051
8052       /* Optimize pow(x,1.0/3.0) = cbrt(x).  */
8053       if (flag_unsafe_math_optimizations)
8054         {
8055           const REAL_VALUE_TYPE dconstroot
8056             = real_value_truncate (TYPE_MODE (type), dconst_third ());
8057
8058           if (REAL_VALUES_EQUAL (c, dconstroot))
8059             {
8060               tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8061               if (cbrtfn != NULL_TREE)
8062                 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8063             }
8064         }
8065
8066       /* Check for an integer exponent.  */
8067       n = real_to_integer (&c);
8068       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8069       if (real_identical (&c, &cint))
8070         {
8071           /* Attempt to evaluate pow at compile-time, unless this should
8072              raise an exception.  */
8073           if (TREE_CODE (arg0) == REAL_CST
8074               && !TREE_OVERFLOW (arg0)
8075               && (n > 0
8076                   || (!flag_trapping_math && !flag_errno_math)
8077                   || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8078             {
8079               REAL_VALUE_TYPE x;
8080               bool inexact;
8081
8082               x = TREE_REAL_CST (arg0);
8083               inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8084               if (flag_unsafe_math_optimizations || !inexact)
8085                 return build_real (type, x);
8086             }
8087
8088           /* Strip sign ops from even integer powers.  */
8089           if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8090             {
8091               tree narg0 = fold_strip_sign_ops (arg0);
8092               if (narg0)
8093                 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8094             }
8095         }
8096     }
8097
8098   if (flag_unsafe_math_optimizations)
8099     {
8100       const enum built_in_function fcode = builtin_mathfn_code (arg0);
8101
8102       /* Optimize pow(expN(x),y) = expN(x*y).  */
8103       if (BUILTIN_EXPONENT_P (fcode))
8104         {
8105           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8106           tree arg = CALL_EXPR_ARG (arg0, 0);
8107           arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8108           return build_call_expr_loc (loc, expfn, 1, arg);
8109         }
8110
8111       /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
8112       if (BUILTIN_SQRT_P (fcode))
8113         {
8114           tree narg0 = CALL_EXPR_ARG (arg0, 0);
8115           tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8116                                     build_real (type, dconsthalf));
8117           return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8118         }
8119
8120       /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative.  */
8121       if (BUILTIN_CBRT_P (fcode))
8122         {
8123           tree arg = CALL_EXPR_ARG (arg0, 0);
8124           if (tree_expr_nonnegative_p (arg))
8125             {
8126               const REAL_VALUE_TYPE dconstroot
8127                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8128               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8129                                         build_real (type, dconstroot));
8130               return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8131             }
8132         }
8133
8134       /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative.  */
8135       if (fcode == BUILT_IN_POW
8136           || fcode == BUILT_IN_POWF
8137           || fcode == BUILT_IN_POWL)
8138         {
8139           tree arg00 = CALL_EXPR_ARG (arg0, 0);
8140           if (tree_expr_nonnegative_p (arg00))
8141             {
8142               tree arg01 = CALL_EXPR_ARG (arg0, 1);
8143               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8144               return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8145             }
8146         }
8147     }
8148
8149   return NULL_TREE;
8150 }
8151
8152 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8153    Return NULL_TREE if no simplification can be made.  */
8154 static tree
8155 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8156                    tree arg0, tree arg1, tree type)
8157 {
8158   if (!validate_arg (arg0, REAL_TYPE)
8159       || !validate_arg (arg1, INTEGER_TYPE))
8160     return NULL_TREE;
8161
8162   /* Optimize pow(1.0,y) = 1.0.  */
8163   if (real_onep (arg0))
8164     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8165
8166   if (host_integerp (arg1, 0))
8167     {
8168       HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8169
8170       /* Evaluate powi at compile-time.  */
8171       if (TREE_CODE (arg0) == REAL_CST
8172           && !TREE_OVERFLOW (arg0))
8173         {
8174           REAL_VALUE_TYPE x;
8175           x = TREE_REAL_CST (arg0);
8176           real_powi (&x, TYPE_MODE (type), &x, c);
8177           return build_real (type, x);
8178         }
8179
8180       /* Optimize pow(x,0) = 1.0.  */
8181       if (c == 0)
8182         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8183                                  arg0);
8184
8185       /* Optimize pow(x,1) = x.  */
8186       if (c == 1)
8187         return arg0;
8188
8189       /* Optimize pow(x,-1) = 1.0/x.  */
8190       if (c == -1)
8191         return fold_build2_loc (loc, RDIV_EXPR, type,
8192                            build_real (type, dconst1), arg0);
8193     }
8194
8195   return NULL_TREE;
8196 }
8197
8198 /* A subroutine of fold_builtin to fold the various exponent
8199    functions.  Return NULL_TREE if no simplification can be made.
8200    FUNC is the corresponding MPFR exponent function.  */
8201
8202 static tree
8203 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8204                        int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8205 {
8206   if (validate_arg (arg, REAL_TYPE))
8207     {
8208       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8209       tree res;
8210
8211       /* Calculate the result when the argument is a constant.  */
8212       if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8213         return res;
8214
8215       /* Optimize expN(logN(x)) = x.  */
8216       if (flag_unsafe_math_optimizations)
8217         {
8218           const enum built_in_function fcode = builtin_mathfn_code (arg);
8219
8220           if ((func == mpfr_exp
8221                && (fcode == BUILT_IN_LOG
8222                    || fcode == BUILT_IN_LOGF
8223                    || fcode == BUILT_IN_LOGL))
8224               || (func == mpfr_exp2
8225                   && (fcode == BUILT_IN_LOG2
8226                       || fcode == BUILT_IN_LOG2F
8227                       || fcode == BUILT_IN_LOG2L))
8228               || (func == mpfr_exp10
8229                   && (fcode == BUILT_IN_LOG10
8230                       || fcode == BUILT_IN_LOG10F
8231                       || fcode == BUILT_IN_LOG10L)))
8232             return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8233         }
8234     }
8235
8236   return NULL_TREE;
8237 }
8238
8239 /* Return true if VAR is a VAR_DECL or a component thereof.  */
8240
8241 static bool
8242 var_decl_component_p (tree var)
8243 {
8244   tree inner = var;
8245   while (handled_component_p (inner))
8246     inner = TREE_OPERAND (inner, 0);
8247   return SSA_VAR_P (inner);
8248 }
8249
8250 /* Fold function call to builtin memset.  Return
8251    NULL_TREE if no simplification can be made.  */
8252
8253 static tree
8254 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8255                      tree type, bool ignore)
8256 {
8257   tree var, ret, etype;
8258   unsigned HOST_WIDE_INT length, cval;
8259
8260   if (! validate_arg (dest, POINTER_TYPE)
8261       || ! validate_arg (c, INTEGER_TYPE)
8262       || ! validate_arg (len, INTEGER_TYPE))
8263     return NULL_TREE;
8264
8265   if (! host_integerp (len, 1))
8266     return NULL_TREE;
8267
8268   /* If the LEN parameter is zero, return DEST.  */
8269   if (integer_zerop (len))
8270     return omit_one_operand_loc (loc, type, dest, c);
8271
8272   if (TREE_CODE (c) != INTEGER_CST || TREE_SIDE_EFFECTS (dest))
8273     return NULL_TREE;
8274
8275   var = dest;
8276   STRIP_NOPS (var);
8277   if (TREE_CODE (var) != ADDR_EXPR)
8278     return NULL_TREE;
8279
8280   var = TREE_OPERAND (var, 0);
8281   if (TREE_THIS_VOLATILE (var))
8282     return NULL_TREE;
8283
8284   etype = TREE_TYPE (var);
8285   if (TREE_CODE (etype) == ARRAY_TYPE)
8286     etype = TREE_TYPE (etype);
8287
8288   if (!INTEGRAL_TYPE_P (etype)
8289       && !POINTER_TYPE_P (etype))
8290     return NULL_TREE;
8291
8292   if (! var_decl_component_p (var))
8293     return NULL_TREE;
8294
8295   length = tree_low_cst (len, 1);
8296   if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8297       || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8298          < length)
8299     return NULL_TREE;
8300
8301   if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8302     return NULL_TREE;
8303
8304   if (integer_zerop (c))
8305     cval = 0;
8306   else
8307     {
8308       if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8309         return NULL_TREE;
8310
8311       cval = TREE_INT_CST_LOW (c);
8312       cval &= 0xff;
8313       cval |= cval << 8;
8314       cval |= cval << 16;
8315       cval |= (cval << 31) << 1;
8316     }
8317
8318   ret = build_int_cst_type (etype, cval);
8319   var = build_fold_indirect_ref_loc (loc,
8320                                  fold_convert_loc (loc,
8321                                                    build_pointer_type (etype),
8322                                                    dest));
8323   ret = build2 (MODIFY_EXPR, etype, var, ret);
8324   if (ignore)
8325     return ret;
8326
8327   return omit_one_operand_loc (loc, type, dest, ret);
8328 }
8329
8330 /* Fold function call to builtin memset.  Return
8331    NULL_TREE if no simplification can be made.  */
8332
8333 static tree
8334 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8335 {
8336   if (! validate_arg (dest, POINTER_TYPE)
8337       || ! validate_arg (size, INTEGER_TYPE))
8338     return NULL_TREE;
8339
8340   if (!ignore)
8341     return NULL_TREE;
8342
8343   /* New argument list transforming bzero(ptr x, int y) to
8344      memset(ptr x, int 0, size_t y).   This is done this way
8345      so that if it isn't expanded inline, we fallback to
8346      calling bzero instead of memset.  */
8347
8348   return fold_builtin_memset (loc, dest, integer_zero_node,
8349                               fold_convert_loc (loc, sizetype, size),
8350                               void_type_node, ignore);
8351 }
8352
8353 /* Fold function call to builtin mem{{,p}cpy,move}.  Return
8354    NULL_TREE if no simplification can be made.
8355    If ENDP is 0, return DEST (like memcpy).
8356    If ENDP is 1, return DEST+LEN (like mempcpy).
8357    If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8358    If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8359    (memmove).   */
8360
8361 static tree
8362 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8363                         tree len, tree type, bool ignore, int endp)
8364 {
8365   tree destvar, srcvar, expr;
8366
8367   if (! validate_arg (dest, POINTER_TYPE)
8368       || ! validate_arg (src, POINTER_TYPE)
8369       || ! validate_arg (len, INTEGER_TYPE))
8370     return NULL_TREE;
8371
8372   /* If the LEN parameter is zero, return DEST.  */
8373   if (integer_zerop (len))
8374     return omit_one_operand_loc (loc, type, dest, src);
8375
8376   /* If SRC and DEST are the same (and not volatile), return
8377      DEST{,+LEN,+LEN-1}.  */
8378   if (operand_equal_p (src, dest, 0))
8379     expr = len;
8380   else
8381     {
8382       tree srctype, desttype;
8383       unsigned int src_align, dest_align;
8384       tree off0;
8385
8386       if (endp == 3)
8387         {
8388           src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8389           dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8390
8391           /* Both DEST and SRC must be pointer types.
8392              ??? This is what old code did.  Is the testing for pointer types
8393              really mandatory?
8394
8395              If either SRC is readonly or length is 1, we can use memcpy.  */
8396           if (!dest_align || !src_align)
8397             return NULL_TREE;
8398           if (readonly_data_expr (src)
8399               || (host_integerp (len, 1)
8400                   && (MIN (src_align, dest_align) / BITS_PER_UNIT
8401                       >= (unsigned HOST_WIDE_INT) tree_low_cst (len, 1))))
8402             {
8403               tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8404               if (!fn)
8405                 return NULL_TREE;
8406               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8407             }
8408
8409           /* If *src and *dest can't overlap, optimize into memcpy as well.  */
8410           if (TREE_CODE (src) == ADDR_EXPR
8411               && TREE_CODE (dest) == ADDR_EXPR)
8412             {
8413               tree src_base, dest_base, fn;
8414               HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8415               HOST_WIDE_INT size = -1;
8416               HOST_WIDE_INT maxsize = -1;
8417
8418               srcvar = TREE_OPERAND (src, 0);
8419               src_base = get_ref_base_and_extent (srcvar, &src_offset,
8420                                                   &size, &maxsize);
8421               destvar = TREE_OPERAND (dest, 0);
8422               dest_base = get_ref_base_and_extent (destvar, &dest_offset,
8423                                                    &size, &maxsize);
8424               if (host_integerp (len, 1))
8425                 maxsize = tree_low_cst (len, 1);
8426               else
8427                 maxsize = -1;
8428               src_offset /= BITS_PER_UNIT;
8429               dest_offset /= BITS_PER_UNIT;
8430               if (SSA_VAR_P (src_base)
8431                   && SSA_VAR_P (dest_base))
8432                 {
8433                   if (operand_equal_p (src_base, dest_base, 0)
8434                       && ranges_overlap_p (src_offset, maxsize,
8435                                            dest_offset, maxsize))
8436                     return NULL_TREE;
8437                 }
8438               else if (TREE_CODE (src_base) == MEM_REF
8439                        && TREE_CODE (dest_base) == MEM_REF)
8440                 {
8441                   double_int off;
8442                   if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8443                                          TREE_OPERAND (dest_base, 0), 0))
8444                     return NULL_TREE;
8445                   off = double_int_add (mem_ref_offset (src_base),
8446                                         shwi_to_double_int (src_offset));
8447                   if (!double_int_fits_in_shwi_p (off))
8448                     return NULL_TREE;
8449                   src_offset = off.low;
8450                   off = double_int_add (mem_ref_offset (dest_base),
8451                                         shwi_to_double_int (dest_offset));
8452                   if (!double_int_fits_in_shwi_p (off))
8453                     return NULL_TREE;
8454                   dest_offset = off.low;
8455                   if (ranges_overlap_p (src_offset, maxsize,
8456                                         dest_offset, maxsize))
8457                     return NULL_TREE;
8458                 }
8459               else
8460                 return NULL_TREE;
8461
8462               fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8463               if (!fn)
8464                 return NULL_TREE;
8465               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8466             }
8467
8468           /* If the destination and source do not alias optimize into
8469              memcpy as well.  */
8470           if ((is_gimple_min_invariant (dest)
8471                || TREE_CODE (dest) == SSA_NAME)
8472               && (is_gimple_min_invariant (src)
8473                   || TREE_CODE (src) == SSA_NAME))
8474             {
8475               ao_ref destr, srcr;
8476               ao_ref_init_from_ptr_and_size (&destr, dest, len);
8477               ao_ref_init_from_ptr_and_size (&srcr, src, len);
8478               if (!refs_may_alias_p_1 (&destr, &srcr, false))
8479                 {
8480                   tree fn;
8481                   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8482                   if (!fn)
8483                     return NULL_TREE;
8484                   return build_call_expr_loc (loc, fn, 3, dest, src, len);
8485                 }
8486             }
8487
8488           return NULL_TREE;
8489         }
8490
8491       if (!host_integerp (len, 0))
8492         return NULL_TREE;
8493       /* FIXME:
8494          This logic lose for arguments like (type *)malloc (sizeof (type)),
8495          since we strip the casts of up to VOID return value from malloc.
8496          Perhaps we ought to inherit type from non-VOID argument here?  */
8497       STRIP_NOPS (src);
8498       STRIP_NOPS (dest);
8499       /* As we fold (void *)(p + CST) to (void *)p + CST undo this here.  */
8500       if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8501         {
8502           tree tem = TREE_OPERAND (src, 0);
8503           STRIP_NOPS (tem);
8504           if (tem != TREE_OPERAND (src, 0))
8505             src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8506         }
8507       if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8508         {
8509           tree tem = TREE_OPERAND (dest, 0);
8510           STRIP_NOPS (tem);
8511           if (tem != TREE_OPERAND (dest, 0))
8512             dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8513         }
8514       srctype = TREE_TYPE (TREE_TYPE (src));
8515       if (srctype
8516           && TREE_CODE (srctype) == ARRAY_TYPE
8517           && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8518         {
8519           srctype = TREE_TYPE (srctype);
8520           STRIP_NOPS (src);
8521           src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8522         }
8523       desttype = TREE_TYPE (TREE_TYPE (dest));
8524       if (desttype
8525           && TREE_CODE (desttype) == ARRAY_TYPE
8526           && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8527         {
8528           desttype = TREE_TYPE (desttype);
8529           STRIP_NOPS (dest);
8530           dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8531         }
8532       if (!srctype || !desttype
8533           || TREE_ADDRESSABLE (srctype)
8534           || TREE_ADDRESSABLE (desttype)
8535           || !TYPE_SIZE_UNIT (srctype)
8536           || !TYPE_SIZE_UNIT (desttype)
8537           || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
8538           || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST)
8539         return NULL_TREE;
8540
8541       src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8542       dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8543       if (dest_align < TYPE_ALIGN (desttype)
8544           || src_align < TYPE_ALIGN (srctype))
8545         return NULL_TREE;
8546
8547       if (!ignore)
8548         dest = builtin_save_expr (dest);
8549
8550       /* Build accesses at offset zero with a ref-all character type.  */
8551       off0 = build_int_cst (build_pointer_type_for_mode (char_type_node,
8552                                                          ptr_mode, true), 0);
8553
8554       destvar = dest;
8555       STRIP_NOPS (destvar);
8556       if (TREE_CODE (destvar) == ADDR_EXPR
8557           && var_decl_component_p (TREE_OPERAND (destvar, 0))
8558           && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8559         destvar = fold_build2 (MEM_REF, desttype, destvar, off0);
8560       else
8561         destvar = NULL_TREE;
8562
8563       srcvar = src;
8564       STRIP_NOPS (srcvar);
8565       if (TREE_CODE (srcvar) == ADDR_EXPR
8566           && var_decl_component_p (TREE_OPERAND (srcvar, 0))
8567           && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8568         {
8569           if (!destvar
8570               || src_align >= TYPE_ALIGN (desttype))
8571             srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype,
8572                                   srcvar, off0);
8573           else if (!STRICT_ALIGNMENT)
8574             {
8575               srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8576                                             src_align);
8577               srcvar = fold_build2 (MEM_REF, srctype, srcvar, off0);
8578             }
8579           else
8580             srcvar = NULL_TREE;
8581         }
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           STRIP_NOPS (src);
8591           if (src_align >= TYPE_ALIGN (desttype))
8592             srcvar = fold_build2 (MEM_REF, desttype, src, off0);
8593           else
8594             {
8595               if (STRICT_ALIGNMENT)
8596                 return NULL_TREE;
8597               srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8598                                             src_align);
8599               srcvar = fold_build2 (MEM_REF, srctype, src, off0);
8600             }
8601         }
8602       else if (destvar == NULL_TREE)
8603         {
8604           STRIP_NOPS (dest);
8605           if (dest_align >= TYPE_ALIGN (srctype))
8606             destvar = fold_build2 (MEM_REF, srctype, dest, off0);
8607           else
8608             {
8609               if (STRICT_ALIGNMENT)
8610                 return NULL_TREE;
8611               desttype = build_aligned_type (TYPE_MAIN_VARIANT (srctype),
8612                                              dest_align);
8613               destvar = fold_build2 (MEM_REF, desttype, dest, off0);
8614             }
8615         }
8616
8617       expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, srcvar);
8618     }
8619
8620   if (ignore)
8621     return expr;
8622
8623   if (endp == 0 || endp == 3)
8624     return omit_one_operand_loc (loc, type, dest, expr);
8625
8626   if (expr == len)
8627     expr = NULL_TREE;
8628
8629   if (endp == 2)
8630     len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
8631                        ssize_int (1));
8632
8633   len = fold_convert_loc (loc, sizetype, len);
8634   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8635   dest = fold_convert_loc (loc, type, dest);
8636   if (expr)
8637     dest = omit_one_operand_loc (loc, type, dest, expr);
8638   return dest;
8639 }
8640
8641 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8642    If LEN is not NULL, it represents the length of the string to be
8643    copied.  Return NULL_TREE if no simplification can be made.  */
8644
8645 tree
8646 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
8647 {
8648   tree fn;
8649
8650   if (!validate_arg (dest, POINTER_TYPE)
8651       || !validate_arg (src, POINTER_TYPE))
8652     return NULL_TREE;
8653
8654   /* If SRC and DEST are the same (and not volatile), return DEST.  */
8655   if (operand_equal_p (src, dest, 0))
8656     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
8657
8658   if (optimize_function_for_size_p (cfun))
8659     return NULL_TREE;
8660
8661   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8662   if (!fn)
8663     return NULL_TREE;
8664
8665   if (!len)
8666     {
8667       len = c_strlen (src, 1);
8668       if (! len || TREE_SIDE_EFFECTS (len))
8669         return NULL_TREE;
8670     }
8671
8672   len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8673   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8674                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8675 }
8676
8677 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
8678    Return NULL_TREE if no simplification can be made.  */
8679
8680 static tree
8681 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
8682 {
8683   tree fn, len, lenp1, call, type;
8684
8685   if (!validate_arg (dest, POINTER_TYPE)
8686       || !validate_arg (src, POINTER_TYPE))
8687     return NULL_TREE;
8688
8689   len = c_strlen (src, 1);
8690   if (!len
8691       || TREE_CODE (len) != INTEGER_CST)
8692     return NULL_TREE;
8693
8694   if (optimize_function_for_size_p (cfun)
8695       /* If length is zero it's small enough.  */
8696       && !integer_zerop (len))
8697     return NULL_TREE;
8698
8699   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8700   if (!fn)
8701     return NULL_TREE;
8702
8703   lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8704   /* We use dest twice in building our expression.  Save it from
8705      multiple expansions.  */
8706   dest = builtin_save_expr (dest);
8707   call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
8708
8709   type = TREE_TYPE (TREE_TYPE (fndecl));
8710   len = fold_convert_loc (loc, sizetype, len);
8711   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8712   dest = fold_convert_loc (loc, type, dest);
8713   dest = omit_one_operand_loc (loc, type, dest, call);
8714   return dest;
8715 }
8716
8717 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8718    If SLEN is not NULL, it represents the length of the source string.
8719    Return NULL_TREE if no simplification can be made.  */
8720
8721 tree
8722 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
8723                       tree src, tree len, tree slen)
8724 {
8725   tree fn;
8726
8727   if (!validate_arg (dest, POINTER_TYPE)
8728       || !validate_arg (src, POINTER_TYPE)
8729       || !validate_arg (len, INTEGER_TYPE))
8730     return NULL_TREE;
8731
8732   /* If the LEN parameter is zero, return DEST.  */
8733   if (integer_zerop (len))
8734     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8735
8736   /* We can't compare slen with len as constants below if len is not a
8737      constant.  */
8738   if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8739     return NULL_TREE;
8740
8741   if (!slen)
8742     slen = c_strlen (src, 1);
8743
8744   /* Now, we must be passed a constant src ptr parameter.  */
8745   if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8746     return NULL_TREE;
8747
8748   slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
8749
8750   /* We do not support simplification of this case, though we do
8751      support it when expanding trees into RTL.  */
8752   /* FIXME: generate a call to __builtin_memset.  */
8753   if (tree_int_cst_lt (slen, len))
8754     return NULL_TREE;
8755
8756   /* OK transform into builtin memcpy.  */
8757   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8758   if (!fn)
8759     return NULL_TREE;
8760   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8761                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8762 }
8763
8764 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
8765    arguments to the call, and TYPE is its return type.
8766    Return NULL_TREE if no simplification can be made.  */
8767
8768 static tree
8769 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
8770 {
8771   if (!validate_arg (arg1, POINTER_TYPE)
8772       || !validate_arg (arg2, INTEGER_TYPE)
8773       || !validate_arg (len, INTEGER_TYPE))
8774     return NULL_TREE;
8775   else
8776     {
8777       const char *p1;
8778
8779       if (TREE_CODE (arg2) != INTEGER_CST
8780           || !host_integerp (len, 1))
8781         return NULL_TREE;
8782
8783       p1 = c_getstr (arg1);
8784       if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
8785         {
8786           char c;
8787           const char *r;
8788           tree tem;
8789
8790           if (target_char_cast (arg2, &c))
8791             return NULL_TREE;
8792
8793           r = (char *) memchr (p1, c, tree_low_cst (len, 1));
8794
8795           if (r == NULL)
8796             return build_int_cst (TREE_TYPE (arg1), 0);
8797
8798           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
8799                              size_int (r - p1));
8800           return fold_convert_loc (loc, type, tem);
8801         }
8802       return NULL_TREE;
8803     }
8804 }
8805
8806 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8807    Return NULL_TREE if no simplification can be made.  */
8808
8809 static tree
8810 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
8811 {
8812   const char *p1, *p2;
8813
8814   if (!validate_arg (arg1, POINTER_TYPE)
8815       || !validate_arg (arg2, POINTER_TYPE)
8816       || !validate_arg (len, INTEGER_TYPE))
8817     return NULL_TREE;
8818
8819   /* If the LEN parameter is zero, return zero.  */
8820   if (integer_zerop (len))
8821     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8822                               arg1, arg2);
8823
8824   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8825   if (operand_equal_p (arg1, arg2, 0))
8826     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8827
8828   p1 = c_getstr (arg1);
8829   p2 = c_getstr (arg2);
8830
8831   /* If all arguments are constant, and the value of len is not greater
8832      than the lengths of arg1 and arg2, evaluate at compile-time.  */
8833   if (host_integerp (len, 1) && p1 && p2
8834       && compare_tree_int (len, strlen (p1) + 1) <= 0
8835       && compare_tree_int (len, strlen (p2) + 1) <= 0)
8836     {
8837       const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8838
8839       if (r > 0)
8840         return integer_one_node;
8841       else if (r < 0)
8842         return integer_minus_one_node;
8843       else
8844         return integer_zero_node;
8845     }
8846
8847   /* If len parameter is one, return an expression corresponding to
8848      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
8849   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8850     {
8851       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8852       tree cst_uchar_ptr_node
8853         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8854
8855       tree ind1
8856         = fold_convert_loc (loc, integer_type_node,
8857                             build1 (INDIRECT_REF, cst_uchar_node,
8858                                     fold_convert_loc (loc,
8859                                                       cst_uchar_ptr_node,
8860                                                       arg1)));
8861       tree ind2
8862         = fold_convert_loc (loc, integer_type_node,
8863                             build1 (INDIRECT_REF, cst_uchar_node,
8864                                     fold_convert_loc (loc,
8865                                                       cst_uchar_ptr_node,
8866                                                       arg2)));
8867       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8868     }
8869
8870   return NULL_TREE;
8871 }
8872
8873 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8874    Return NULL_TREE if no simplification can be made.  */
8875
8876 static tree
8877 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
8878 {
8879   const char *p1, *p2;
8880
8881   if (!validate_arg (arg1, POINTER_TYPE)
8882       || !validate_arg (arg2, POINTER_TYPE))
8883     return NULL_TREE;
8884
8885   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8886   if (operand_equal_p (arg1, arg2, 0))
8887     return integer_zero_node;
8888
8889   p1 = c_getstr (arg1);
8890   p2 = c_getstr (arg2);
8891
8892   if (p1 && p2)
8893     {
8894       const int i = strcmp (p1, p2);
8895       if (i < 0)
8896         return integer_minus_one_node;
8897       else if (i > 0)
8898         return integer_one_node;
8899       else
8900         return integer_zero_node;
8901     }
8902
8903   /* If the second arg is "", return *(const unsigned char*)arg1.  */
8904   if (p2 && *p2 == '\0')
8905     {
8906       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8907       tree cst_uchar_ptr_node
8908         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8909
8910       return fold_convert_loc (loc, integer_type_node,
8911                                build1 (INDIRECT_REF, cst_uchar_node,
8912                                        fold_convert_loc (loc,
8913                                                          cst_uchar_ptr_node,
8914                                                          arg1)));
8915     }
8916
8917   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
8918   if (p1 && *p1 == '\0')
8919     {
8920       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8921       tree cst_uchar_ptr_node
8922         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8923
8924       tree temp
8925         = fold_convert_loc (loc, integer_type_node,
8926                             build1 (INDIRECT_REF, cst_uchar_node,
8927                                     fold_convert_loc (loc,
8928                                                       cst_uchar_ptr_node,
8929                                                       arg2)));
8930       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8931     }
8932
8933   return NULL_TREE;
8934 }
8935
8936 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
8937    Return NULL_TREE if no simplification can be made.  */
8938
8939 static tree
8940 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
8941 {
8942   const char *p1, *p2;
8943
8944   if (!validate_arg (arg1, POINTER_TYPE)
8945       || !validate_arg (arg2, POINTER_TYPE)
8946       || !validate_arg (len, INTEGER_TYPE))
8947     return NULL_TREE;
8948
8949   /* If the LEN parameter is zero, return zero.  */
8950   if (integer_zerop (len))
8951     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8952                               arg1, arg2);
8953
8954   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8955   if (operand_equal_p (arg1, arg2, 0))
8956     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8957
8958   p1 = c_getstr (arg1);
8959   p2 = c_getstr (arg2);
8960
8961   if (host_integerp (len, 1) && p1 && p2)
8962     {
8963       const int i = strncmp (p1, p2, tree_low_cst (len, 1));
8964       if (i > 0)
8965         return integer_one_node;
8966       else if (i < 0)
8967         return integer_minus_one_node;
8968       else
8969         return integer_zero_node;
8970     }
8971
8972   /* If the second arg is "", and the length is greater than zero,
8973      return *(const unsigned char*)arg1.  */
8974   if (p2 && *p2 == '\0'
8975       && TREE_CODE (len) == INTEGER_CST
8976       && tree_int_cst_sgn (len) == 1)
8977     {
8978       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8979       tree cst_uchar_ptr_node
8980         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8981
8982       return fold_convert_loc (loc, integer_type_node,
8983                                build1 (INDIRECT_REF, cst_uchar_node,
8984                                        fold_convert_loc (loc,
8985                                                          cst_uchar_ptr_node,
8986                                                          arg1)));
8987     }
8988
8989   /* If the first arg is "", and the length is greater than zero,
8990      return -*(const unsigned char*)arg2.  */
8991   if (p1 && *p1 == '\0'
8992       && TREE_CODE (len) == INTEGER_CST
8993       && tree_int_cst_sgn (len) == 1)
8994     {
8995       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8996       tree cst_uchar_ptr_node
8997         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8998
8999       tree temp = fold_convert_loc (loc, integer_type_node,
9000                                     build1 (INDIRECT_REF, cst_uchar_node,
9001                                             fold_convert_loc (loc,
9002                                                               cst_uchar_ptr_node,
9003                                                               arg2)));
9004       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9005     }
9006
9007   /* If len parameter is one, return an expression corresponding to
9008      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
9009   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9010     {
9011       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9012       tree cst_uchar_ptr_node
9013         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9014
9015       tree ind1 = fold_convert_loc (loc, integer_type_node,
9016                                     build1 (INDIRECT_REF, cst_uchar_node,
9017                                             fold_convert_loc (loc,
9018                                                               cst_uchar_ptr_node,
9019                                                               arg1)));
9020       tree ind2 = fold_convert_loc (loc, integer_type_node,
9021                                     build1 (INDIRECT_REF, cst_uchar_node,
9022                                             fold_convert_loc (loc,
9023                                                               cst_uchar_ptr_node,
9024                                                               arg2)));
9025       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9026     }
9027
9028   return NULL_TREE;
9029 }
9030
9031 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9032    ARG.  Return NULL_TREE if no simplification can be made.  */
9033
9034 static tree
9035 fold_builtin_signbit (location_t loc, tree arg, tree type)
9036 {
9037   if (!validate_arg (arg, REAL_TYPE))
9038     return NULL_TREE;
9039
9040   /* If ARG is a compile-time constant, determine the result.  */
9041   if (TREE_CODE (arg) == REAL_CST
9042       && !TREE_OVERFLOW (arg))
9043     {
9044       REAL_VALUE_TYPE c;
9045
9046       c = TREE_REAL_CST (arg);
9047       return (REAL_VALUE_NEGATIVE (c)
9048               ? build_one_cst (type)
9049               : build_zero_cst (type));
9050     }
9051
9052   /* If ARG is non-negative, the result is always zero.  */
9053   if (tree_expr_nonnegative_p (arg))
9054     return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9055
9056   /* If ARG's format doesn't have signed zeros, return "arg < 0.0".  */
9057   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9058     return fold_build2_loc (loc, LT_EXPR, type, arg,
9059                         build_real (TREE_TYPE (arg), dconst0));
9060
9061   return NULL_TREE;
9062 }
9063
9064 /* Fold function call to builtin copysign, copysignf or copysignl with
9065    arguments ARG1 and ARG2.  Return NULL_TREE if no simplification can
9066    be made.  */
9067
9068 static tree
9069 fold_builtin_copysign (location_t loc, tree fndecl,
9070                        tree arg1, tree arg2, tree type)
9071 {
9072   tree tem;
9073
9074   if (!validate_arg (arg1, REAL_TYPE)
9075       || !validate_arg (arg2, REAL_TYPE))
9076     return NULL_TREE;
9077
9078   /* copysign(X,X) is X.  */
9079   if (operand_equal_p (arg1, arg2, 0))
9080     return fold_convert_loc (loc, type, arg1);
9081
9082   /* If ARG1 and ARG2 are compile-time constants, determine the result.  */
9083   if (TREE_CODE (arg1) == REAL_CST
9084       && TREE_CODE (arg2) == REAL_CST
9085       && !TREE_OVERFLOW (arg1)
9086       && !TREE_OVERFLOW (arg2))
9087     {
9088       REAL_VALUE_TYPE c1, c2;
9089
9090       c1 = TREE_REAL_CST (arg1);
9091       c2 = TREE_REAL_CST (arg2);
9092       /* c1.sign := c2.sign.  */
9093       real_copysign (&c1, &c2);
9094       return build_real (type, c1);
9095     }
9096
9097   /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9098      Remember to evaluate Y for side-effects.  */
9099   if (tree_expr_nonnegative_p (arg2))
9100     return omit_one_operand_loc (loc, type,
9101                              fold_build1_loc (loc, ABS_EXPR, type, arg1),
9102                              arg2);
9103
9104   /* Strip sign changing operations for the first argument.  */
9105   tem = fold_strip_sign_ops (arg1);
9106   if (tem)
9107     return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9108
9109   return NULL_TREE;
9110 }
9111
9112 /* Fold a call to builtin isascii with argument ARG.  */
9113
9114 static tree
9115 fold_builtin_isascii (location_t loc, tree arg)
9116 {
9117   if (!validate_arg (arg, INTEGER_TYPE))
9118     return NULL_TREE;
9119   else
9120     {
9121       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
9122       arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9123                          build_int_cst (NULL_TREE,
9124                                         ~ (unsigned HOST_WIDE_INT) 0x7f));
9125       return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9126                           arg, integer_zero_node);
9127     }
9128 }
9129
9130 /* Fold a call to builtin toascii with argument ARG.  */
9131
9132 static tree
9133 fold_builtin_toascii (location_t loc, tree arg)
9134 {
9135   if (!validate_arg (arg, INTEGER_TYPE))
9136     return NULL_TREE;
9137
9138   /* Transform toascii(c) -> (c & 0x7f).  */
9139   return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9140                       build_int_cst (NULL_TREE, 0x7f));
9141 }
9142
9143 /* Fold a call to builtin isdigit with argument ARG.  */
9144
9145 static tree
9146 fold_builtin_isdigit (location_t loc, tree arg)
9147 {
9148   if (!validate_arg (arg, INTEGER_TYPE))
9149     return NULL_TREE;
9150   else
9151     {
9152       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
9153       /* According to the C standard, isdigit is unaffected by locale.
9154          However, it definitely is affected by the target character set.  */
9155       unsigned HOST_WIDE_INT target_digit0
9156         = lang_hooks.to_target_charset ('0');
9157
9158       if (target_digit0 == 0)
9159         return NULL_TREE;
9160
9161       arg = fold_convert_loc (loc, unsigned_type_node, arg);
9162       arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9163                          build_int_cst (unsigned_type_node, target_digit0));
9164       return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9165                           build_int_cst (unsigned_type_node, 9));
9166     }
9167 }
9168
9169 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
9170
9171 static tree
9172 fold_builtin_fabs (location_t loc, tree arg, tree type)
9173 {
9174   if (!validate_arg (arg, REAL_TYPE))
9175     return NULL_TREE;
9176
9177   arg = fold_convert_loc (loc, type, arg);
9178   if (TREE_CODE (arg) == REAL_CST)
9179     return fold_abs_const (arg, type);
9180   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9181 }
9182
9183 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
9184
9185 static tree
9186 fold_builtin_abs (location_t loc, tree arg, tree type)
9187 {
9188   if (!validate_arg (arg, INTEGER_TYPE))
9189     return NULL_TREE;
9190
9191   arg = fold_convert_loc (loc, type, arg);
9192   if (TREE_CODE (arg) == INTEGER_CST)
9193     return fold_abs_const (arg, type);
9194   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9195 }
9196
9197 /* Fold a fma operation with arguments ARG[012].  */
9198
9199 tree
9200 fold_fma (location_t loc ATTRIBUTE_UNUSED,
9201           tree type, tree arg0, tree arg1, tree arg2)
9202 {
9203   if (TREE_CODE (arg0) == REAL_CST
9204       && TREE_CODE (arg1) == REAL_CST
9205       && TREE_CODE (arg2) == REAL_CST)
9206     return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
9207
9208   return NULL_TREE;
9209 }
9210
9211 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012].  */
9212
9213 static tree
9214 fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type)
9215 {
9216   if (validate_arg (arg0, REAL_TYPE)
9217       && validate_arg(arg1, REAL_TYPE)
9218       && validate_arg(arg2, REAL_TYPE))
9219     {
9220       tree tem = fold_fma (loc, type, arg0, arg1, arg2);
9221       if (tem)
9222         return tem;
9223
9224       /* ??? Only expand to FMA_EXPR if it's directly supported.  */
9225       if (optab_handler (fma_optab, TYPE_MODE (type)) != CODE_FOR_nothing)
9226         return fold_build3_loc (loc, FMA_EXPR, type, arg0, arg1, arg2);
9227     }
9228   return NULL_TREE;
9229 }
9230
9231 /* Fold a call to builtin fmin or fmax.  */
9232
9233 static tree
9234 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9235                         tree type, bool max)
9236 {
9237   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9238     {
9239       /* Calculate the result when the argument is a constant.  */
9240       tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9241
9242       if (res)
9243         return res;
9244
9245       /* If either argument is NaN, return the other one.  Avoid the
9246          transformation if we get (and honor) a signalling NaN.  Using
9247          omit_one_operand() ensures we create a non-lvalue.  */
9248       if (TREE_CODE (arg0) == REAL_CST
9249           && real_isnan (&TREE_REAL_CST (arg0))
9250           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9251               || ! TREE_REAL_CST (arg0).signalling))
9252         return omit_one_operand_loc (loc, type, arg1, arg0);
9253       if (TREE_CODE (arg1) == REAL_CST
9254           && real_isnan (&TREE_REAL_CST (arg1))
9255           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9256               || ! TREE_REAL_CST (arg1).signalling))
9257         return omit_one_operand_loc (loc, type, arg0, arg1);
9258
9259       /* Transform fmin/fmax(x,x) -> x.  */
9260       if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9261         return omit_one_operand_loc (loc, type, arg0, arg1);
9262
9263       /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR.  C99 requires these
9264          functions to return the numeric arg if the other one is NaN.
9265          These tree codes don't honor that, so only transform if
9266          -ffinite-math-only is set.  C99 doesn't require -0.0 to be
9267          handled, so we don't have to worry about it either.  */
9268       if (flag_finite_math_only)
9269         return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9270                             fold_convert_loc (loc, type, arg0),
9271                             fold_convert_loc (loc, type, arg1));
9272     }
9273   return NULL_TREE;
9274 }
9275
9276 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
9277
9278 static tree
9279 fold_builtin_carg (location_t loc, tree arg, tree type)
9280 {
9281   if (validate_arg (arg, COMPLEX_TYPE)
9282       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9283     {
9284       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9285
9286       if (atan2_fn)
9287         {
9288           tree new_arg = builtin_save_expr (arg);
9289           tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9290           tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9291           return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9292         }
9293     }
9294
9295   return NULL_TREE;
9296 }
9297
9298 /* Fold a call to builtin logb/ilogb.  */
9299
9300 static tree
9301 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9302 {
9303   if (! validate_arg (arg, REAL_TYPE))
9304     return NULL_TREE;
9305
9306   STRIP_NOPS (arg);
9307
9308   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9309     {
9310       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9311
9312       switch (value->cl)
9313       {
9314       case rvc_nan:
9315       case rvc_inf:
9316         /* If arg is Inf or NaN and we're logb, return it.  */
9317         if (TREE_CODE (rettype) == REAL_TYPE)
9318           return fold_convert_loc (loc, rettype, arg);
9319         /* Fall through... */
9320       case rvc_zero:
9321         /* Zero may set errno and/or raise an exception for logb, also
9322            for ilogb we don't know FP_ILOGB0.  */
9323         return NULL_TREE;
9324       case rvc_normal:
9325         /* For normal numbers, proceed iff radix == 2.  In GCC,
9326            normalized significands are in the range [0.5, 1.0).  We
9327            want the exponent as if they were [1.0, 2.0) so get the
9328            exponent and subtract 1.  */
9329         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9330           return fold_convert_loc (loc, rettype,
9331                                    build_int_cst (NULL_TREE,
9332                                                   REAL_EXP (value)-1));
9333         break;
9334       }
9335     }
9336
9337   return NULL_TREE;
9338 }
9339
9340 /* Fold a call to builtin significand, if radix == 2.  */
9341
9342 static tree
9343 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9344 {
9345   if (! validate_arg (arg, REAL_TYPE))
9346     return NULL_TREE;
9347
9348   STRIP_NOPS (arg);
9349
9350   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9351     {
9352       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9353
9354       switch (value->cl)
9355       {
9356       case rvc_zero:
9357       case rvc_nan:
9358       case rvc_inf:
9359         /* If arg is +-0, +-Inf or +-NaN, then return it.  */
9360         return fold_convert_loc (loc, rettype, arg);
9361       case rvc_normal:
9362         /* For normal numbers, proceed iff radix == 2.  */
9363         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9364           {
9365             REAL_VALUE_TYPE result = *value;
9366             /* In GCC, normalized significands are in the range [0.5,
9367                1.0).  We want them to be [1.0, 2.0) so set the
9368                exponent to 1.  */
9369             SET_REAL_EXP (&result, 1);
9370             return build_real (rettype, result);
9371           }
9372         break;
9373       }
9374     }
9375
9376   return NULL_TREE;
9377 }
9378
9379 /* Fold a call to builtin frexp, we can assume the base is 2.  */
9380
9381 static tree
9382 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9383 {
9384   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9385     return NULL_TREE;
9386
9387   STRIP_NOPS (arg0);
9388
9389   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9390     return NULL_TREE;
9391
9392   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9393
9394   /* Proceed if a valid pointer type was passed in.  */
9395   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9396     {
9397       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9398       tree frac, exp;
9399
9400       switch (value->cl)
9401       {
9402       case rvc_zero:
9403         /* For +-0, return (*exp = 0, +-0).  */
9404         exp = integer_zero_node;
9405         frac = arg0;
9406         break;
9407       case rvc_nan:
9408       case rvc_inf:
9409         /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
9410         return omit_one_operand_loc (loc, rettype, arg0, arg1);
9411       case rvc_normal:
9412         {
9413           /* Since the frexp function always expects base 2, and in
9414              GCC normalized significands are already in the range
9415              [0.5, 1.0), we have exactly what frexp wants.  */
9416           REAL_VALUE_TYPE frac_rvt = *value;
9417           SET_REAL_EXP (&frac_rvt, 0);
9418           frac = build_real (rettype, frac_rvt);
9419           exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9420         }
9421         break;
9422       default:
9423         gcc_unreachable ();
9424       }
9425
9426       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9427       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9428       TREE_SIDE_EFFECTS (arg1) = 1;
9429       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9430     }
9431
9432   return NULL_TREE;
9433 }
9434
9435 /* Fold a call to builtin ldexp or scalbn/scalbln.  If LDEXP is true
9436    then we can assume the base is two.  If it's false, then we have to
9437    check the mode of the TYPE parameter in certain cases.  */
9438
9439 static tree
9440 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9441                             tree type, bool ldexp)
9442 {
9443   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9444     {
9445       STRIP_NOPS (arg0);
9446       STRIP_NOPS (arg1);
9447
9448       /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0.  */
9449       if (real_zerop (arg0) || integer_zerop (arg1)
9450           || (TREE_CODE (arg0) == REAL_CST
9451               && !real_isfinite (&TREE_REAL_CST (arg0))))
9452         return omit_one_operand_loc (loc, type, arg0, arg1);
9453
9454       /* If both arguments are constant, then try to evaluate it.  */
9455       if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9456           && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9457           && host_integerp (arg1, 0))
9458         {
9459           /* Bound the maximum adjustment to twice the range of the
9460              mode's valid exponents.  Use abs to ensure the range is
9461              positive as a sanity check.  */
9462           const long max_exp_adj = 2 *
9463             labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9464                  - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9465
9466           /* Get the user-requested adjustment.  */
9467           const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9468
9469           /* The requested adjustment must be inside this range.  This
9470              is a preliminary cap to avoid things like overflow, we
9471              may still fail to compute the result for other reasons.  */
9472           if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9473             {
9474               REAL_VALUE_TYPE initial_result;
9475
9476               real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9477
9478               /* Ensure we didn't overflow.  */
9479               if (! real_isinf (&initial_result))
9480                 {
9481                   const REAL_VALUE_TYPE trunc_result
9482                     = real_value_truncate (TYPE_MODE (type), initial_result);
9483
9484                   /* Only proceed if the target mode can hold the
9485                      resulting value.  */
9486                   if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9487                     return build_real (type, trunc_result);
9488                 }
9489             }
9490         }
9491     }
9492
9493   return NULL_TREE;
9494 }
9495
9496 /* Fold a call to builtin modf.  */
9497
9498 static tree
9499 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9500 {
9501   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9502     return NULL_TREE;
9503
9504   STRIP_NOPS (arg0);
9505
9506   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9507     return NULL_TREE;
9508
9509   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9510
9511   /* Proceed if a valid pointer type was passed in.  */
9512   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9513     {
9514       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9515       REAL_VALUE_TYPE trunc, frac;
9516
9517       switch (value->cl)
9518       {
9519       case rvc_nan:
9520       case rvc_zero:
9521         /* For +-NaN or +-0, return (*arg1 = arg0, arg0).  */
9522         trunc = frac = *value;
9523         break;
9524       case rvc_inf:
9525         /* For +-Inf, return (*arg1 = arg0, +-0).  */
9526         frac = dconst0;
9527         frac.sign = value->sign;
9528         trunc = *value;
9529         break;
9530       case rvc_normal:
9531         /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)).  */
9532         real_trunc (&trunc, VOIDmode, value);
9533         real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9534         /* If the original number was negative and already
9535            integral, then the fractional part is -0.0.  */
9536         if (value->sign && frac.cl == rvc_zero)
9537           frac.sign = value->sign;
9538         break;
9539       }
9540
9541       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9542       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9543                           build_real (rettype, trunc));
9544       TREE_SIDE_EFFECTS (arg1) = 1;
9545       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9546                           build_real (rettype, frac));
9547     }
9548
9549   return NULL_TREE;
9550 }
9551
9552 /* Given a location LOC, an interclass builtin function decl FNDECL
9553    and its single argument ARG, return an folded expression computing
9554    the same, or NULL_TREE if we either couldn't or didn't want to fold
9555    (the latter happen if there's an RTL instruction available).  */
9556
9557 static tree
9558 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9559 {
9560   enum machine_mode mode;
9561
9562   if (!validate_arg (arg, REAL_TYPE))
9563     return NULL_TREE;
9564
9565   if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9566     return NULL_TREE;
9567
9568   mode = TYPE_MODE (TREE_TYPE (arg));
9569
9570   /* If there is no optab, try generic code.  */
9571   switch (DECL_FUNCTION_CODE (fndecl))
9572     {
9573       tree result;
9574
9575     CASE_FLT_FN (BUILT_IN_ISINF):
9576       {
9577         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
9578         tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
9579         tree const type = TREE_TYPE (arg);
9580         REAL_VALUE_TYPE r;
9581         char buf[128];
9582
9583         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9584         real_from_string (&r, buf);
9585         result = build_call_expr (isgr_fn, 2,
9586                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9587                                   build_real (type, r));
9588         return result;
9589       }
9590     CASE_FLT_FN (BUILT_IN_FINITE):
9591     case BUILT_IN_ISFINITE:
9592       {
9593         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
9594         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9595         tree const type = TREE_TYPE (arg);
9596         REAL_VALUE_TYPE r;
9597         char buf[128];
9598
9599         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9600         real_from_string (&r, buf);
9601         result = build_call_expr (isle_fn, 2,
9602                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9603                                   build_real (type, r));
9604         /*result = fold_build2_loc (loc, UNGT_EXPR,
9605                                   TREE_TYPE (TREE_TYPE (fndecl)),
9606                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9607                                   build_real (type, r));
9608         result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9609                                   TREE_TYPE (TREE_TYPE (fndecl)),
9610                                   result);*/
9611         return result;
9612       }
9613     case BUILT_IN_ISNORMAL:
9614       {
9615         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9616            islessequal(fabs(x),DBL_MAX).  */
9617         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9618         tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
9619         tree const type = TREE_TYPE (arg);
9620         REAL_VALUE_TYPE rmax, rmin;
9621         char buf[128];
9622
9623         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9624         real_from_string (&rmax, buf);
9625         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9626         real_from_string (&rmin, buf);
9627         arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9628         result = build_call_expr (isle_fn, 2, arg,
9629                                   build_real (type, rmax));
9630         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
9631                               build_call_expr (isge_fn, 2, arg,
9632                                                build_real (type, rmin)));
9633         return result;
9634       }
9635     default:
9636       break;
9637     }
9638
9639   return NULL_TREE;
9640 }
9641
9642 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9643    ARG is the argument for the call.  */
9644
9645 static tree
9646 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
9647 {
9648   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9649   REAL_VALUE_TYPE r;
9650
9651   if (!validate_arg (arg, REAL_TYPE))
9652     return NULL_TREE;
9653
9654   switch (builtin_index)
9655     {
9656     case BUILT_IN_ISINF:
9657       if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9658         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9659
9660       if (TREE_CODE (arg) == REAL_CST)
9661         {
9662           r = TREE_REAL_CST (arg);
9663           if (real_isinf (&r))
9664             return real_compare (GT_EXPR, &r, &dconst0)
9665                    ? integer_one_node : integer_minus_one_node;
9666           else
9667             return integer_zero_node;
9668         }
9669
9670       return NULL_TREE;
9671
9672     case BUILT_IN_ISINF_SIGN:
9673       {
9674         /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9675         /* In a boolean context, GCC will fold the inner COND_EXPR to
9676            1.  So e.g. "if (isinf_sign(x))" would be folded to just
9677            "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9678         tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
9679         tree isinf_fn = built_in_decls[BUILT_IN_ISINF];
9680         tree tmp = NULL_TREE;
9681
9682         arg = builtin_save_expr (arg);
9683
9684         if (signbit_fn && isinf_fn)
9685           {
9686             tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
9687             tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
9688
9689             signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9690                                         signbit_call, integer_zero_node);
9691             isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9692                                       isinf_call, integer_zero_node);
9693
9694             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
9695                                integer_minus_one_node, integer_one_node);
9696             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9697                                isinf_call, tmp,
9698                                integer_zero_node);
9699           }
9700
9701         return tmp;
9702       }
9703
9704     case BUILT_IN_ISFINITE:
9705       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
9706           && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9707         return omit_one_operand_loc (loc, type, integer_one_node, arg);
9708
9709       if (TREE_CODE (arg) == REAL_CST)
9710         {
9711           r = TREE_REAL_CST (arg);
9712           return real_isfinite (&r) ? integer_one_node : integer_zero_node;
9713         }
9714
9715       return NULL_TREE;
9716
9717     case BUILT_IN_ISNAN:
9718       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
9719         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9720
9721       if (TREE_CODE (arg) == REAL_CST)
9722         {
9723           r = TREE_REAL_CST (arg);
9724           return real_isnan (&r) ? integer_one_node : integer_zero_node;
9725         }
9726
9727       arg = builtin_save_expr (arg);
9728       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
9729
9730     default:
9731       gcc_unreachable ();
9732     }
9733 }
9734
9735 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9736    This builtin will generate code to return the appropriate floating
9737    point classification depending on the value of the floating point
9738    number passed in.  The possible return values must be supplied as
9739    int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9740    FP_NORMAL, FP_SUBNORMAL and FP_ZERO.  The ellipses is for exactly
9741    one floating point argument which is "type generic".  */
9742
9743 static tree
9744 fold_builtin_fpclassify (location_t loc, tree exp)
9745 {
9746   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
9747     arg, type, res, tmp;
9748   enum machine_mode mode;
9749   REAL_VALUE_TYPE r;
9750   char buf[128];
9751
9752   /* Verify the required arguments in the original call.  */
9753   if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
9754                          INTEGER_TYPE, INTEGER_TYPE,
9755                          INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
9756     return NULL_TREE;
9757
9758   fp_nan = CALL_EXPR_ARG (exp, 0);
9759   fp_infinite = CALL_EXPR_ARG (exp, 1);
9760   fp_normal = CALL_EXPR_ARG (exp, 2);
9761   fp_subnormal = CALL_EXPR_ARG (exp, 3);
9762   fp_zero = CALL_EXPR_ARG (exp, 4);
9763   arg = CALL_EXPR_ARG (exp, 5);
9764   type = TREE_TYPE (arg);
9765   mode = TYPE_MODE (type);
9766   arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9767
9768   /* fpclassify(x) ->
9769        isnan(x) ? FP_NAN :
9770          (fabs(x) == Inf ? FP_INFINITE :
9771            (fabs(x) >= DBL_MIN ? FP_NORMAL :
9772              (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
9773
9774   tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9775                      build_real (type, dconst0));
9776   res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9777                      tmp, fp_zero, fp_subnormal);
9778
9779   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9780   real_from_string (&r, buf);
9781   tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
9782                      arg, build_real (type, r));
9783   res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
9784
9785   if (HONOR_INFINITIES (mode))
9786     {
9787       real_inf (&r);
9788       tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9789                          build_real (type, r));
9790       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
9791                          fp_infinite, res);
9792     }
9793
9794   if (HONOR_NANS (mode))
9795     {
9796       tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
9797       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
9798     }
9799
9800   return res;
9801 }
9802
9803 /* Fold a call to an unordered comparison function such as
9804    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
9805    being called and ARG0 and ARG1 are the arguments for the call.
9806    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9807    the opposite of the desired result.  UNORDERED_CODE is used
9808    for modes that can hold NaNs and ORDERED_CODE is used for
9809    the rest.  */
9810
9811 static tree
9812 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
9813                             enum tree_code unordered_code,
9814                             enum tree_code ordered_code)
9815 {
9816   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9817   enum tree_code code;
9818   tree type0, type1;
9819   enum tree_code code0, code1;
9820   tree cmp_type = NULL_TREE;
9821
9822   type0 = TREE_TYPE (arg0);
9823   type1 = TREE_TYPE (arg1);
9824
9825   code0 = TREE_CODE (type0);
9826   code1 = TREE_CODE (type1);
9827
9828   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
9829     /* Choose the wider of two real types.  */
9830     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
9831       ? type0 : type1;
9832   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
9833     cmp_type = type0;
9834   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
9835     cmp_type = type1;
9836
9837   arg0 = fold_convert_loc (loc, cmp_type, arg0);
9838   arg1 = fold_convert_loc (loc, cmp_type, arg1);
9839
9840   if (unordered_code == UNORDERED_EXPR)
9841     {
9842       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9843         return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
9844       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
9845     }
9846
9847   code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
9848                                                    : ordered_code;
9849   return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
9850                       fold_build2_loc (loc, code, type, arg0, arg1));
9851 }
9852
9853 /* Fold a call to built-in function FNDECL with 0 arguments.
9854    IGNORE is true if the result of the function call is ignored.  This
9855    function returns NULL_TREE if no simplification was possible.  */
9856
9857 static tree
9858 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
9859 {
9860   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9861   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9862   switch (fcode)
9863     {
9864     CASE_FLT_FN (BUILT_IN_INF):
9865     case BUILT_IN_INFD32:
9866     case BUILT_IN_INFD64:
9867     case BUILT_IN_INFD128:
9868       return fold_builtin_inf (loc, type, true);
9869
9870     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
9871       return fold_builtin_inf (loc, type, false);
9872
9873     case BUILT_IN_CLASSIFY_TYPE:
9874       return fold_builtin_classify_type (NULL_TREE);
9875
9876     default:
9877       break;
9878     }
9879   return NULL_TREE;
9880 }
9881
9882 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9883    IGNORE is true if the result of the function call is ignored.  This
9884    function returns NULL_TREE if no simplification was possible.  */
9885
9886 static tree
9887 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
9888 {
9889   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9890   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9891   switch (fcode)
9892     {
9893     case BUILT_IN_CONSTANT_P:
9894       {
9895         tree val = fold_builtin_constant_p (arg0);
9896
9897         /* Gimplification will pull the CALL_EXPR for the builtin out of
9898            an if condition.  When not optimizing, we'll not CSE it back.
9899            To avoid link error types of regressions, return false now.  */
9900         if (!val && !optimize)
9901           val = integer_zero_node;
9902
9903         return val;
9904       }
9905
9906     case BUILT_IN_CLASSIFY_TYPE:
9907       return fold_builtin_classify_type (arg0);
9908
9909     case BUILT_IN_STRLEN:
9910       return fold_builtin_strlen (loc, type, arg0);
9911
9912     CASE_FLT_FN (BUILT_IN_FABS):
9913       return fold_builtin_fabs (loc, arg0, type);
9914
9915     case BUILT_IN_ABS:
9916     case BUILT_IN_LABS:
9917     case BUILT_IN_LLABS:
9918     case BUILT_IN_IMAXABS:
9919       return fold_builtin_abs (loc, arg0, type);
9920
9921     CASE_FLT_FN (BUILT_IN_CONJ):
9922       if (validate_arg (arg0, COMPLEX_TYPE)
9923         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9924         return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
9925     break;
9926
9927     CASE_FLT_FN (BUILT_IN_CREAL):
9928       if (validate_arg (arg0, COMPLEX_TYPE)
9929         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9930         return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
9931     break;
9932
9933     CASE_FLT_FN (BUILT_IN_CIMAG):
9934       if (validate_arg (arg0, COMPLEX_TYPE)
9935           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9936         return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
9937     break;
9938
9939     CASE_FLT_FN (BUILT_IN_CCOS):
9940       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
9941
9942     CASE_FLT_FN (BUILT_IN_CCOSH):
9943       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
9944
9945     CASE_FLT_FN (BUILT_IN_CPROJ):
9946       return fold_builtin_cproj(loc, arg0, type);
9947
9948     CASE_FLT_FN (BUILT_IN_CSIN):
9949       if (validate_arg (arg0, COMPLEX_TYPE)
9950           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9951         return do_mpc_arg1 (arg0, type, mpc_sin);
9952     break;
9953
9954     CASE_FLT_FN (BUILT_IN_CSINH):
9955       if (validate_arg (arg0, COMPLEX_TYPE)
9956           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9957         return do_mpc_arg1 (arg0, type, mpc_sinh);
9958     break;
9959
9960     CASE_FLT_FN (BUILT_IN_CTAN):
9961       if (validate_arg (arg0, COMPLEX_TYPE)
9962           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9963         return do_mpc_arg1 (arg0, type, mpc_tan);
9964     break;
9965
9966     CASE_FLT_FN (BUILT_IN_CTANH):
9967       if (validate_arg (arg0, COMPLEX_TYPE)
9968           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9969         return do_mpc_arg1 (arg0, type, mpc_tanh);
9970     break;
9971
9972     CASE_FLT_FN (BUILT_IN_CLOG):
9973       if (validate_arg (arg0, COMPLEX_TYPE)
9974           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9975         return do_mpc_arg1 (arg0, type, mpc_log);
9976     break;
9977
9978     CASE_FLT_FN (BUILT_IN_CSQRT):
9979       if (validate_arg (arg0, COMPLEX_TYPE)
9980           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9981         return do_mpc_arg1 (arg0, type, mpc_sqrt);
9982     break;
9983
9984     CASE_FLT_FN (BUILT_IN_CASIN):
9985       if (validate_arg (arg0, COMPLEX_TYPE)
9986           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9987         return do_mpc_arg1 (arg0, type, mpc_asin);
9988     break;
9989
9990     CASE_FLT_FN (BUILT_IN_CACOS):
9991       if (validate_arg (arg0, COMPLEX_TYPE)
9992           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9993         return do_mpc_arg1 (arg0, type, mpc_acos);
9994     break;
9995
9996     CASE_FLT_FN (BUILT_IN_CATAN):
9997       if (validate_arg (arg0, COMPLEX_TYPE)
9998           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9999         return do_mpc_arg1 (arg0, type, mpc_atan);
10000     break;
10001
10002     CASE_FLT_FN (BUILT_IN_CASINH):
10003       if (validate_arg (arg0, COMPLEX_TYPE)
10004           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10005         return do_mpc_arg1 (arg0, type, mpc_asinh);
10006     break;
10007
10008     CASE_FLT_FN (BUILT_IN_CACOSH):
10009       if (validate_arg (arg0, COMPLEX_TYPE)
10010           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10011         return do_mpc_arg1 (arg0, type, mpc_acosh);
10012     break;
10013
10014     CASE_FLT_FN (BUILT_IN_CATANH):
10015       if (validate_arg (arg0, COMPLEX_TYPE)
10016           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10017         return do_mpc_arg1 (arg0, type, mpc_atanh);
10018     break;
10019
10020     CASE_FLT_FN (BUILT_IN_CABS):
10021       return fold_builtin_cabs (loc, arg0, type, fndecl);
10022
10023     CASE_FLT_FN (BUILT_IN_CARG):
10024       return fold_builtin_carg (loc, arg0, type);
10025
10026     CASE_FLT_FN (BUILT_IN_SQRT):
10027       return fold_builtin_sqrt (loc, arg0, type);
10028
10029     CASE_FLT_FN (BUILT_IN_CBRT):
10030       return fold_builtin_cbrt (loc, arg0, type);
10031
10032     CASE_FLT_FN (BUILT_IN_ASIN):
10033       if (validate_arg (arg0, REAL_TYPE))
10034         return do_mpfr_arg1 (arg0, type, mpfr_asin,
10035                              &dconstm1, &dconst1, true);
10036     break;
10037
10038     CASE_FLT_FN (BUILT_IN_ACOS):
10039       if (validate_arg (arg0, REAL_TYPE))
10040         return do_mpfr_arg1 (arg0, type, mpfr_acos,
10041                              &dconstm1, &dconst1, true);
10042     break;
10043
10044     CASE_FLT_FN (BUILT_IN_ATAN):
10045       if (validate_arg (arg0, REAL_TYPE))
10046         return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10047     break;
10048
10049     CASE_FLT_FN (BUILT_IN_ASINH):
10050       if (validate_arg (arg0, REAL_TYPE))
10051         return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10052     break;
10053
10054     CASE_FLT_FN (BUILT_IN_ACOSH):
10055       if (validate_arg (arg0, REAL_TYPE))
10056         return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10057                              &dconst1, NULL, true);
10058     break;
10059
10060     CASE_FLT_FN (BUILT_IN_ATANH):
10061       if (validate_arg (arg0, REAL_TYPE))
10062         return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10063                              &dconstm1, &dconst1, false);
10064     break;
10065
10066     CASE_FLT_FN (BUILT_IN_SIN):
10067       if (validate_arg (arg0, REAL_TYPE))
10068         return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10069     break;
10070
10071     CASE_FLT_FN (BUILT_IN_COS):
10072       return fold_builtin_cos (loc, arg0, type, fndecl);
10073
10074     CASE_FLT_FN (BUILT_IN_TAN):
10075       return fold_builtin_tan (arg0, type);
10076
10077     CASE_FLT_FN (BUILT_IN_CEXP):
10078       return fold_builtin_cexp (loc, arg0, type);
10079
10080     CASE_FLT_FN (BUILT_IN_CEXPI):
10081       if (validate_arg (arg0, REAL_TYPE))
10082         return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10083     break;
10084
10085     CASE_FLT_FN (BUILT_IN_SINH):
10086       if (validate_arg (arg0, REAL_TYPE))
10087         return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10088     break;
10089
10090     CASE_FLT_FN (BUILT_IN_COSH):
10091       return fold_builtin_cosh (loc, arg0, type, fndecl);
10092
10093     CASE_FLT_FN (BUILT_IN_TANH):
10094       if (validate_arg (arg0, REAL_TYPE))
10095         return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10096     break;
10097
10098     CASE_FLT_FN (BUILT_IN_ERF):
10099       if (validate_arg (arg0, REAL_TYPE))
10100         return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10101     break;
10102
10103     CASE_FLT_FN (BUILT_IN_ERFC):
10104       if (validate_arg (arg0, REAL_TYPE))
10105         return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10106     break;
10107
10108     CASE_FLT_FN (BUILT_IN_TGAMMA):
10109       if (validate_arg (arg0, REAL_TYPE))
10110         return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10111     break;
10112
10113     CASE_FLT_FN (BUILT_IN_EXP):
10114       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10115
10116     CASE_FLT_FN (BUILT_IN_EXP2):
10117       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10118
10119     CASE_FLT_FN (BUILT_IN_EXP10):
10120     CASE_FLT_FN (BUILT_IN_POW10):
10121       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10122
10123     CASE_FLT_FN (BUILT_IN_EXPM1):
10124       if (validate_arg (arg0, REAL_TYPE))
10125         return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10126     break;
10127
10128     CASE_FLT_FN (BUILT_IN_LOG):
10129     return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10130
10131     CASE_FLT_FN (BUILT_IN_LOG2):
10132       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10133
10134     CASE_FLT_FN (BUILT_IN_LOG10):
10135       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10136
10137     CASE_FLT_FN (BUILT_IN_LOG1P):
10138       if (validate_arg (arg0, REAL_TYPE))
10139         return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10140                              &dconstm1, NULL, false);
10141     break;
10142
10143     CASE_FLT_FN (BUILT_IN_J0):
10144       if (validate_arg (arg0, REAL_TYPE))
10145         return do_mpfr_arg1 (arg0, type, mpfr_j0,
10146                              NULL, NULL, 0);
10147     break;
10148
10149     CASE_FLT_FN (BUILT_IN_J1):
10150       if (validate_arg (arg0, REAL_TYPE))
10151         return do_mpfr_arg1 (arg0, type, mpfr_j1,
10152                              NULL, NULL, 0);
10153     break;
10154
10155     CASE_FLT_FN (BUILT_IN_Y0):
10156       if (validate_arg (arg0, REAL_TYPE))
10157         return do_mpfr_arg1 (arg0, type, mpfr_y0,
10158                              &dconst0, NULL, false);
10159     break;
10160
10161     CASE_FLT_FN (BUILT_IN_Y1):
10162       if (validate_arg (arg0, REAL_TYPE))
10163         return do_mpfr_arg1 (arg0, type, mpfr_y1,
10164                              &dconst0, NULL, false);
10165     break;
10166
10167     CASE_FLT_FN (BUILT_IN_NAN):
10168     case BUILT_IN_NAND32:
10169     case BUILT_IN_NAND64:
10170     case BUILT_IN_NAND128:
10171       return fold_builtin_nan (arg0, type, true);
10172
10173     CASE_FLT_FN (BUILT_IN_NANS):
10174       return fold_builtin_nan (arg0, type, false);
10175
10176     CASE_FLT_FN (BUILT_IN_FLOOR):
10177       return fold_builtin_floor (loc, fndecl, arg0);
10178
10179     CASE_FLT_FN (BUILT_IN_CEIL):
10180       return fold_builtin_ceil (loc, fndecl, arg0);
10181
10182     CASE_FLT_FN (BUILT_IN_TRUNC):
10183       return fold_builtin_trunc (loc, fndecl, arg0);
10184
10185     CASE_FLT_FN (BUILT_IN_ROUND):
10186       return fold_builtin_round (loc, fndecl, arg0);
10187
10188     CASE_FLT_FN (BUILT_IN_NEARBYINT):
10189     CASE_FLT_FN (BUILT_IN_RINT):
10190       return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10191
10192     CASE_FLT_FN (BUILT_IN_LCEIL):
10193     CASE_FLT_FN (BUILT_IN_LLCEIL):
10194     CASE_FLT_FN (BUILT_IN_LFLOOR):
10195     CASE_FLT_FN (BUILT_IN_LLFLOOR):
10196     CASE_FLT_FN (BUILT_IN_LROUND):
10197     CASE_FLT_FN (BUILT_IN_LLROUND):
10198       return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10199
10200     CASE_FLT_FN (BUILT_IN_LRINT):
10201     CASE_FLT_FN (BUILT_IN_LLRINT):
10202       return fold_fixed_mathfn (loc, fndecl, arg0);
10203
10204     case BUILT_IN_BSWAP32:
10205     case BUILT_IN_BSWAP64:
10206       return fold_builtin_bswap (fndecl, arg0);
10207
10208     CASE_INT_FN (BUILT_IN_FFS):
10209     CASE_INT_FN (BUILT_IN_CLZ):
10210     CASE_INT_FN (BUILT_IN_CTZ):
10211     CASE_INT_FN (BUILT_IN_POPCOUNT):
10212     CASE_INT_FN (BUILT_IN_PARITY):
10213       return fold_builtin_bitop (fndecl, arg0);
10214
10215     CASE_FLT_FN (BUILT_IN_SIGNBIT):
10216       return fold_builtin_signbit (loc, arg0, type);
10217
10218     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10219       return fold_builtin_significand (loc, arg0, type);
10220
10221     CASE_FLT_FN (BUILT_IN_ILOGB):
10222     CASE_FLT_FN (BUILT_IN_LOGB):
10223       return fold_builtin_logb (loc, arg0, type);
10224
10225     case BUILT_IN_ISASCII:
10226       return fold_builtin_isascii (loc, arg0);
10227
10228     case BUILT_IN_TOASCII:
10229       return fold_builtin_toascii (loc, arg0);
10230
10231     case BUILT_IN_ISDIGIT:
10232       return fold_builtin_isdigit (loc, arg0);
10233
10234     CASE_FLT_FN (BUILT_IN_FINITE):
10235     case BUILT_IN_FINITED32:
10236     case BUILT_IN_FINITED64:
10237     case BUILT_IN_FINITED128:
10238     case BUILT_IN_ISFINITE:
10239       {
10240         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10241         if (ret)
10242           return ret;
10243         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10244       }
10245
10246     CASE_FLT_FN (BUILT_IN_ISINF):
10247     case BUILT_IN_ISINFD32:
10248     case BUILT_IN_ISINFD64:
10249     case BUILT_IN_ISINFD128:
10250       {
10251         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10252         if (ret)
10253           return ret;
10254         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10255       }
10256
10257     case BUILT_IN_ISNORMAL:
10258       return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10259
10260     case BUILT_IN_ISINF_SIGN:
10261       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10262
10263     CASE_FLT_FN (BUILT_IN_ISNAN):
10264     case BUILT_IN_ISNAND32:
10265     case BUILT_IN_ISNAND64:
10266     case BUILT_IN_ISNAND128:
10267       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10268
10269     case BUILT_IN_PRINTF:
10270     case BUILT_IN_PRINTF_UNLOCKED:
10271     case BUILT_IN_VPRINTF:
10272       return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10273
10274     case BUILT_IN_FREE:
10275       if (integer_zerop (arg0))
10276         return build_empty_stmt (loc);
10277       break;
10278
10279     default:
10280       break;
10281     }
10282
10283   return NULL_TREE;
10284
10285 }
10286
10287 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10288    IGNORE is true if the result of the function call is ignored.  This
10289    function returns NULL_TREE if no simplification was possible.  */
10290
10291 static tree
10292 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10293 {
10294   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10295   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10296
10297   switch (fcode)
10298     {
10299     CASE_FLT_FN (BUILT_IN_JN):
10300       if (validate_arg (arg0, INTEGER_TYPE)
10301           && validate_arg (arg1, REAL_TYPE))
10302         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10303     break;
10304
10305     CASE_FLT_FN (BUILT_IN_YN):
10306       if (validate_arg (arg0, INTEGER_TYPE)
10307           && validate_arg (arg1, REAL_TYPE))
10308         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10309                                  &dconst0, false);
10310     break;
10311
10312     CASE_FLT_FN (BUILT_IN_DREM):
10313     CASE_FLT_FN (BUILT_IN_REMAINDER):
10314       if (validate_arg (arg0, REAL_TYPE)
10315           && validate_arg(arg1, REAL_TYPE))
10316         return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10317     break;
10318
10319     CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10320     CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10321       if (validate_arg (arg0, REAL_TYPE)
10322           && validate_arg(arg1, POINTER_TYPE))
10323         return do_mpfr_lgamma_r (arg0, arg1, type);
10324     break;
10325
10326     CASE_FLT_FN (BUILT_IN_ATAN2):
10327       if (validate_arg (arg0, REAL_TYPE)
10328           && validate_arg(arg1, REAL_TYPE))
10329         return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10330     break;
10331
10332     CASE_FLT_FN (BUILT_IN_FDIM):
10333       if (validate_arg (arg0, REAL_TYPE)
10334           && validate_arg(arg1, REAL_TYPE))
10335         return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10336     break;
10337
10338     CASE_FLT_FN (BUILT_IN_HYPOT):
10339       return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10340
10341     CASE_FLT_FN (BUILT_IN_CPOW):
10342       if (validate_arg (arg0, COMPLEX_TYPE)
10343           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10344           && validate_arg (arg1, COMPLEX_TYPE)
10345           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10346         return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10347     break;
10348
10349     CASE_FLT_FN (BUILT_IN_LDEXP):
10350       return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10351     CASE_FLT_FN (BUILT_IN_SCALBN):
10352     CASE_FLT_FN (BUILT_IN_SCALBLN):
10353       return fold_builtin_load_exponent (loc, arg0, arg1,
10354                                          type, /*ldexp=*/false);
10355
10356     CASE_FLT_FN (BUILT_IN_FREXP):
10357       return fold_builtin_frexp (loc, arg0, arg1, type);
10358
10359     CASE_FLT_FN (BUILT_IN_MODF):
10360       return fold_builtin_modf (loc, arg0, arg1, type);
10361
10362     case BUILT_IN_BZERO:
10363       return fold_builtin_bzero (loc, arg0, arg1, ignore);
10364
10365     case BUILT_IN_FPUTS:
10366       return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10367
10368     case BUILT_IN_FPUTS_UNLOCKED:
10369       return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10370
10371     case BUILT_IN_STRSTR:
10372       return fold_builtin_strstr (loc, arg0, arg1, type);
10373
10374     case BUILT_IN_STRCAT:
10375       return fold_builtin_strcat (loc, arg0, arg1);
10376
10377     case BUILT_IN_STRSPN:
10378       return fold_builtin_strspn (loc, arg0, arg1);
10379
10380     case BUILT_IN_STRCSPN:
10381       return fold_builtin_strcspn (loc, arg0, arg1);
10382
10383     case BUILT_IN_STRCHR:
10384     case BUILT_IN_INDEX:
10385       return fold_builtin_strchr (loc, arg0, arg1, type);
10386
10387     case BUILT_IN_STRRCHR:
10388     case BUILT_IN_RINDEX:
10389       return fold_builtin_strrchr (loc, arg0, arg1, type);
10390
10391     case BUILT_IN_STRCPY:
10392       return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10393
10394     case BUILT_IN_STPCPY:
10395       if (ignore)
10396         {
10397           tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
10398           if (!fn)
10399             break;
10400
10401           return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10402         }
10403       else
10404         return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10405       break;
10406
10407     case BUILT_IN_STRCMP:
10408       return fold_builtin_strcmp (loc, arg0, arg1);
10409
10410     case BUILT_IN_STRPBRK:
10411       return fold_builtin_strpbrk (loc, arg0, arg1, type);
10412
10413     case BUILT_IN_EXPECT:
10414       return fold_builtin_expect (loc, arg0, arg1);
10415
10416     CASE_FLT_FN (BUILT_IN_POW):
10417       return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10418
10419     CASE_FLT_FN (BUILT_IN_POWI):
10420       return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10421
10422     CASE_FLT_FN (BUILT_IN_COPYSIGN):
10423       return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10424
10425     CASE_FLT_FN (BUILT_IN_FMIN):
10426       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10427
10428     CASE_FLT_FN (BUILT_IN_FMAX):
10429       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10430
10431     case BUILT_IN_ISGREATER:
10432       return fold_builtin_unordered_cmp (loc, fndecl,
10433                                          arg0, arg1, UNLE_EXPR, LE_EXPR);
10434     case BUILT_IN_ISGREATEREQUAL:
10435       return fold_builtin_unordered_cmp (loc, fndecl,
10436                                          arg0, arg1, UNLT_EXPR, LT_EXPR);
10437     case BUILT_IN_ISLESS:
10438       return fold_builtin_unordered_cmp (loc, fndecl,
10439                                          arg0, arg1, UNGE_EXPR, GE_EXPR);
10440     case BUILT_IN_ISLESSEQUAL:
10441       return fold_builtin_unordered_cmp (loc, fndecl,
10442                                          arg0, arg1, UNGT_EXPR, GT_EXPR);
10443     case BUILT_IN_ISLESSGREATER:
10444       return fold_builtin_unordered_cmp (loc, fndecl,
10445                                          arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10446     case BUILT_IN_ISUNORDERED:
10447       return fold_builtin_unordered_cmp (loc, fndecl,
10448                                          arg0, arg1, UNORDERED_EXPR,
10449                                          NOP_EXPR);
10450
10451       /* We do the folding for va_start in the expander.  */
10452     case BUILT_IN_VA_START:
10453       break;
10454
10455     case BUILT_IN_SPRINTF:
10456       return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10457
10458     case BUILT_IN_OBJECT_SIZE:
10459       return fold_builtin_object_size (arg0, arg1);
10460
10461     case BUILT_IN_PRINTF:
10462     case BUILT_IN_PRINTF_UNLOCKED:
10463     case BUILT_IN_VPRINTF:
10464       return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10465
10466     case BUILT_IN_PRINTF_CHK:
10467     case BUILT_IN_VPRINTF_CHK:
10468       if (!validate_arg (arg0, INTEGER_TYPE)
10469           || TREE_SIDE_EFFECTS (arg0))
10470         return NULL_TREE;
10471       else
10472         return fold_builtin_printf (loc, fndecl,
10473                                     arg1, NULL_TREE, ignore, fcode);
10474     break;
10475
10476     case BUILT_IN_FPRINTF:
10477     case BUILT_IN_FPRINTF_UNLOCKED:
10478     case BUILT_IN_VFPRINTF:
10479       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10480                                    ignore, fcode);
10481
10482     default:
10483       break;
10484     }
10485   return NULL_TREE;
10486 }
10487
10488 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10489    and ARG2.  IGNORE is true if the result of the function call is ignored.
10490    This function returns NULL_TREE if no simplification was possible.  */
10491
10492 static tree
10493 fold_builtin_3 (location_t loc, tree fndecl,
10494                 tree arg0, tree arg1, tree arg2, bool ignore)
10495 {
10496   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10497   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10498   switch (fcode)
10499     {
10500
10501     CASE_FLT_FN (BUILT_IN_SINCOS):
10502       return fold_builtin_sincos (loc, arg0, arg1, arg2);
10503
10504     CASE_FLT_FN (BUILT_IN_FMA):
10505       return fold_builtin_fma (loc, arg0, arg1, arg2, type);
10506     break;
10507
10508     CASE_FLT_FN (BUILT_IN_REMQUO):
10509       if (validate_arg (arg0, REAL_TYPE)
10510           && validate_arg(arg1, REAL_TYPE)
10511           && validate_arg(arg2, POINTER_TYPE))
10512         return do_mpfr_remquo (arg0, arg1, arg2);
10513     break;
10514
10515     case BUILT_IN_MEMSET:
10516       return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10517
10518     case BUILT_IN_BCOPY:
10519       return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10520                                      void_type_node, true, /*endp=*/3);
10521
10522     case BUILT_IN_MEMCPY:
10523       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10524                                      type, ignore, /*endp=*/0);
10525
10526     case BUILT_IN_MEMPCPY:
10527       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10528                                      type, ignore, /*endp=*/1);
10529
10530     case BUILT_IN_MEMMOVE:
10531       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10532                                      type, ignore, /*endp=*/3);
10533
10534     case BUILT_IN_STRNCAT:
10535       return fold_builtin_strncat (loc, arg0, arg1, arg2);
10536
10537     case BUILT_IN_STRNCPY:
10538       return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10539
10540     case BUILT_IN_STRNCMP:
10541       return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10542
10543     case BUILT_IN_MEMCHR:
10544       return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10545
10546     case BUILT_IN_BCMP:
10547     case BUILT_IN_MEMCMP:
10548       return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10549
10550     case BUILT_IN_SPRINTF:
10551       return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10552
10553     case BUILT_IN_SNPRINTF:
10554       return fold_builtin_snprintf (loc, arg0, arg1, arg2, NULL_TREE, ignore);
10555
10556     case BUILT_IN_STRCPY_CHK:
10557     case BUILT_IN_STPCPY_CHK:
10558       return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10559                                       ignore, fcode);
10560
10561     case BUILT_IN_STRCAT_CHK:
10562       return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10563
10564     case BUILT_IN_PRINTF_CHK:
10565     case BUILT_IN_VPRINTF_CHK:
10566       if (!validate_arg (arg0, INTEGER_TYPE)
10567           || TREE_SIDE_EFFECTS (arg0))
10568         return NULL_TREE;
10569       else
10570         return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10571     break;
10572
10573     case BUILT_IN_FPRINTF:
10574     case BUILT_IN_FPRINTF_UNLOCKED:
10575     case BUILT_IN_VFPRINTF:
10576       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10577                                    ignore, fcode);
10578
10579     case BUILT_IN_FPRINTF_CHK:
10580     case BUILT_IN_VFPRINTF_CHK:
10581       if (!validate_arg (arg1, INTEGER_TYPE)
10582           || TREE_SIDE_EFFECTS (arg1))
10583         return NULL_TREE;
10584       else
10585         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10586                                      ignore, fcode);
10587
10588     default:
10589       break;
10590     }
10591   return NULL_TREE;
10592 }
10593
10594 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10595    ARG2, and ARG3.  IGNORE is true if the result of the function call is
10596    ignored.  This function returns NULL_TREE if no simplification was
10597    possible.  */
10598
10599 static tree
10600 fold_builtin_4 (location_t loc, tree fndecl,
10601                 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10602 {
10603   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10604
10605   switch (fcode)
10606     {
10607     case BUILT_IN_MEMCPY_CHK:
10608     case BUILT_IN_MEMPCPY_CHK:
10609     case BUILT_IN_MEMMOVE_CHK:
10610     case BUILT_IN_MEMSET_CHK:
10611       return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10612                                       NULL_TREE, ignore,
10613                                       DECL_FUNCTION_CODE (fndecl));
10614
10615     case BUILT_IN_STRNCPY_CHK:
10616       return fold_builtin_strncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE);
10617
10618     case BUILT_IN_STRNCAT_CHK:
10619       return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
10620
10621     case BUILT_IN_SNPRINTF:
10622       return fold_builtin_snprintf (loc, arg0, arg1, arg2, arg3, ignore);
10623
10624     case BUILT_IN_FPRINTF_CHK:
10625     case BUILT_IN_VFPRINTF_CHK:
10626       if (!validate_arg (arg1, INTEGER_TYPE)
10627           || TREE_SIDE_EFFECTS (arg1))
10628         return NULL_TREE;
10629       else
10630         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
10631                                      ignore, fcode);
10632     break;
10633
10634     default:
10635       break;
10636     }
10637   return NULL_TREE;
10638 }
10639
10640 /* Fold a call to built-in function FNDECL.  ARGS is an array of NARGS
10641     arguments, where NARGS <= 4.  IGNORE is true if the result of the
10642     function call is ignored.  This function returns NULL_TREE if no
10643     simplification was possible.  Note that this only folds builtins with
10644     fixed argument patterns.  Foldings that do varargs-to-varargs
10645     transformations, or that match calls with more than 4 arguments,
10646     need to be handled with fold_builtin_varargs instead.  */
10647
10648 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10649
10650 static tree
10651 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
10652 {
10653   tree ret = NULL_TREE;
10654
10655   switch (nargs)
10656     {
10657     case 0:
10658       ret = fold_builtin_0 (loc, fndecl, ignore);
10659       break;
10660     case 1:
10661       ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
10662       break;
10663     case 2:
10664       ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
10665       break;
10666     case 3:
10667       ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
10668       break;
10669     case 4:
10670       ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
10671                             ignore);
10672       break;
10673     default:
10674       break;
10675     }
10676   if (ret)
10677     {
10678       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10679       SET_EXPR_LOCATION (ret, loc);
10680       TREE_NO_WARNING (ret) = 1;
10681       return ret;
10682     }
10683   return NULL_TREE;
10684 }
10685
10686 /* Builtins with folding operations that operate on "..." arguments
10687    need special handling; we need to store the arguments in a convenient
10688    data structure before attempting any folding.  Fortunately there are
10689    only a few builtins that fall into this category.  FNDECL is the
10690    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10691    result of the function call is ignored.  */
10692
10693 static tree
10694 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
10695                       bool ignore ATTRIBUTE_UNUSED)
10696 {
10697   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10698   tree ret = NULL_TREE;
10699
10700   switch (fcode)
10701     {
10702     case BUILT_IN_SPRINTF_CHK:
10703     case BUILT_IN_VSPRINTF_CHK:
10704       ret = fold_builtin_sprintf_chk (loc, exp, fcode);
10705       break;
10706
10707     case BUILT_IN_SNPRINTF_CHK:
10708     case BUILT_IN_VSNPRINTF_CHK:
10709       ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
10710       break;
10711
10712     case BUILT_IN_FPCLASSIFY:
10713       ret = fold_builtin_fpclassify (loc, exp);
10714       break;
10715
10716     default:
10717       break;
10718     }
10719   if (ret)
10720     {
10721       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10722       SET_EXPR_LOCATION (ret, loc);
10723       TREE_NO_WARNING (ret) = 1;
10724       return ret;
10725     }
10726   return NULL_TREE;
10727 }
10728
10729 /* Return true if FNDECL shouldn't be folded right now.
10730    If a built-in function has an inline attribute always_inline
10731    wrapper, defer folding it after always_inline functions have
10732    been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10733    might not be performed.  */
10734
10735 static bool
10736 avoid_folding_inline_builtin (tree fndecl)
10737 {
10738   return (DECL_DECLARED_INLINE_P (fndecl)
10739           && DECL_DISREGARD_INLINE_LIMITS (fndecl)
10740           && cfun
10741           && !cfun->always_inline_functions_inlined
10742           && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
10743 }
10744
10745 /* A wrapper function for builtin folding that prevents warnings for
10746    "statement without effect" and the like, caused by removing the
10747    call node earlier than the warning is generated.  */
10748
10749 tree
10750 fold_call_expr (location_t loc, tree exp, bool ignore)
10751 {
10752   tree ret = NULL_TREE;
10753   tree fndecl = get_callee_fndecl (exp);
10754   if (fndecl
10755       && TREE_CODE (fndecl) == FUNCTION_DECL
10756       && DECL_BUILT_IN (fndecl)
10757       /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10758          yet.  Defer folding until we see all the arguments
10759          (after inlining).  */
10760       && !CALL_EXPR_VA_ARG_PACK (exp))
10761     {
10762       int nargs = call_expr_nargs (exp);
10763
10764       /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10765          instead last argument is __builtin_va_arg_pack ().  Defer folding
10766          even in that case, until arguments are finalized.  */
10767       if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
10768         {
10769           tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
10770           if (fndecl2
10771               && TREE_CODE (fndecl2) == FUNCTION_DECL
10772               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10773               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10774             return NULL_TREE;
10775         }
10776
10777       if (avoid_folding_inline_builtin (fndecl))
10778         return NULL_TREE;
10779
10780       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10781         return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
10782                                      CALL_EXPR_ARGP (exp), ignore);
10783       else
10784         {
10785           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
10786             {
10787               tree *args = CALL_EXPR_ARGP (exp);
10788               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
10789             }
10790           if (!ret)
10791             ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
10792           if (ret)
10793             return ret;
10794         }
10795     }
10796   return NULL_TREE;
10797 }
10798
10799 /* Conveniently construct a function call expression.  FNDECL names the
10800    function to be called and N arguments are passed in the array
10801    ARGARRAY.  */
10802
10803 tree
10804 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
10805 {
10806   tree fntype = TREE_TYPE (fndecl);
10807   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10808
10809   return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10810 }
10811
10812 /* Conveniently construct a function call expression.  FNDECL names the
10813    function to be called and the arguments are passed in the vector
10814    VEC.  */
10815
10816 tree
10817 build_call_expr_loc_vec (location_t loc, tree fndecl, VEC(tree,gc) *vec)
10818 {
10819   return build_call_expr_loc_array (loc, fndecl, VEC_length (tree, vec),
10820                                     VEC_address (tree, vec));
10821 }
10822
10823
10824 /* Conveniently construct a function call expression.  FNDECL names the
10825    function to be called, N is the number of arguments, and the "..."
10826    parameters are the argument expressions.  */
10827
10828 tree
10829 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10830 {
10831   va_list ap;
10832   tree *argarray = XALLOCAVEC (tree, n);
10833   int i;
10834
10835   va_start (ap, n);
10836   for (i = 0; i < n; i++)
10837     argarray[i] = va_arg (ap, tree);
10838   va_end (ap);
10839   return build_call_expr_loc_array (loc, fndecl, n, argarray);
10840 }
10841
10842 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...).  Duplicated because
10843    varargs macros aren't supported by all bootstrap compilers.  */
10844
10845 tree
10846 build_call_expr (tree fndecl, int n, ...)
10847 {
10848   va_list ap;
10849   tree *argarray = XALLOCAVEC (tree, n);
10850   int i;
10851
10852   va_start (ap, n);
10853   for (i = 0; i < n; i++)
10854     argarray[i] = va_arg (ap, tree);
10855   va_end (ap);
10856   return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
10857 }
10858
10859 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10860    N arguments are passed in the array ARGARRAY.  */
10861
10862 tree
10863 fold_builtin_call_array (location_t loc, tree type,
10864                          tree fn,
10865                          int n,
10866                          tree *argarray)
10867 {
10868   tree ret = NULL_TREE;
10869    tree exp;
10870
10871   if (TREE_CODE (fn) == ADDR_EXPR)
10872   {
10873     tree fndecl = TREE_OPERAND (fn, 0);
10874     if (TREE_CODE (fndecl) == FUNCTION_DECL
10875         && DECL_BUILT_IN (fndecl))
10876       {
10877         /* If last argument is __builtin_va_arg_pack (), arguments to this
10878            function are not finalized yet.  Defer folding until they are.  */
10879         if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
10880           {
10881             tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
10882             if (fndecl2
10883                 && TREE_CODE (fndecl2) == FUNCTION_DECL
10884                 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10885                 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10886               return build_call_array_loc (loc, type, fn, n, argarray);
10887           }
10888         if (avoid_folding_inline_builtin (fndecl))
10889           return build_call_array_loc (loc, type, fn, n, argarray);
10890         if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10891           {
10892             ret = targetm.fold_builtin (fndecl, n, argarray, false);
10893             if (ret)
10894               return ret;
10895
10896             return build_call_array_loc (loc, type, fn, n, argarray);
10897           }
10898         else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
10899           {
10900             /* First try the transformations that don't require consing up
10901                an exp.  */
10902             ret = fold_builtin_n (loc, fndecl, argarray, n, false);
10903             if (ret)
10904               return ret;
10905           }
10906
10907         /* If we got this far, we need to build an exp.  */
10908         exp = build_call_array_loc (loc, type, fn, n, argarray);
10909         ret = fold_builtin_varargs (loc, fndecl, exp, false);
10910         return ret ? ret : exp;
10911       }
10912   }
10913
10914   return build_call_array_loc (loc, type, fn, n, argarray);
10915 }
10916
10917 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
10918    list ARGS along with N new arguments in NEWARGS.  SKIP is the number
10919    of arguments in ARGS to be omitted.  OLDNARGS is the number of
10920    elements in ARGS.  */
10921
10922 static tree
10923 rewrite_call_expr_valist (location_t loc, int oldnargs, tree *args,
10924                           int skip, tree fndecl, int n, va_list newargs)
10925 {
10926   int nargs = oldnargs - skip + n;
10927   tree *buffer;
10928
10929   if (n > 0)
10930     {
10931       int i, j;
10932
10933       buffer = XALLOCAVEC (tree, nargs);
10934       for (i = 0; i < n; i++)
10935         buffer[i] = va_arg (newargs, tree);
10936       for (j = skip; j < oldnargs; j++, i++)
10937         buffer[i] = args[j];
10938     }
10939   else
10940     buffer = args + skip;
10941
10942   return build_call_expr_loc_array (loc, fndecl, nargs, buffer);
10943 }
10944
10945 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
10946    list ARGS along with N new arguments specified as the "..."
10947    parameters.  SKIP is the number of arguments in ARGS to be omitted.
10948    OLDNARGS is the number of elements in ARGS.  */
10949
10950 static tree
10951 rewrite_call_expr_array (location_t loc, int oldnargs, tree *args,
10952                          int skip, tree fndecl, int n, ...)
10953 {
10954   va_list ap;
10955   tree t;
10956
10957   va_start (ap, n);
10958   t = rewrite_call_expr_valist (loc, oldnargs, args, skip, fndecl, n, ap);
10959   va_end (ap);
10960
10961   return t;
10962 }
10963
10964 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10965    along with N new arguments specified as the "..." parameters.  SKIP
10966    is the number of arguments in EXP to be omitted.  This function is used
10967    to do varargs-to-varargs transformations.  */
10968
10969 static tree
10970 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
10971 {
10972   va_list ap;
10973   tree t;
10974
10975   va_start (ap, n);
10976   t = rewrite_call_expr_valist (loc, call_expr_nargs (exp),
10977                                 CALL_EXPR_ARGP (exp), skip, fndecl, n, ap);
10978   va_end (ap);
10979
10980   return t;
10981 }
10982
10983 /* Validate a single argument ARG against a tree code CODE representing
10984    a type.  */
10985
10986 static bool
10987 validate_arg (const_tree arg, enum tree_code code)
10988 {
10989   if (!arg)
10990     return false;
10991   else if (code == POINTER_TYPE)
10992     return POINTER_TYPE_P (TREE_TYPE (arg));
10993   else if (code == INTEGER_TYPE)
10994     return INTEGRAL_TYPE_P (TREE_TYPE (arg));
10995   return code == TREE_CODE (TREE_TYPE (arg));
10996 }
10997
10998 /* This function validates the types of a function call argument list
10999    against a specified list of tree_codes.  If the last specifier is a 0,
11000    that represents an ellipses, otherwise the last specifier must be a
11001    VOID_TYPE.
11002
11003    This is the GIMPLE version of validate_arglist.  Eventually we want to
11004    completely convert builtins.c to work from GIMPLEs and the tree based
11005    validate_arglist will then be removed.  */
11006
11007 bool
11008 validate_gimple_arglist (const_gimple call, ...)
11009 {
11010   enum tree_code code;
11011   bool res = 0;
11012   va_list ap;
11013   const_tree arg;
11014   size_t i;
11015
11016   va_start (ap, call);
11017   i = 0;
11018
11019   do
11020     {
11021       code = (enum tree_code) va_arg (ap, int);
11022       switch (code)
11023         {
11024         case 0:
11025           /* This signifies an ellipses, any further arguments are all ok.  */
11026           res = true;
11027           goto end;
11028         case VOID_TYPE:
11029           /* This signifies an endlink, if no arguments remain, return
11030              true, otherwise return false.  */
11031           res = (i == gimple_call_num_args (call));
11032           goto end;
11033         default:
11034           /* If no parameters remain or the parameter's code does not
11035              match the specified code, return false.  Otherwise continue
11036              checking any remaining arguments.  */
11037           arg = gimple_call_arg (call, i++);
11038           if (!validate_arg (arg, code))
11039             goto end;
11040           break;
11041         }
11042     }
11043   while (1);
11044
11045   /* We need gotos here since we can only have one VA_CLOSE in a
11046      function.  */
11047  end: ;
11048   va_end (ap);
11049
11050   return res;
11051 }
11052
11053 /* This function validates the types of a function call argument list
11054    against a specified list of tree_codes.  If the last specifier is a 0,
11055    that represents an ellipses, otherwise the last specifier must be a
11056    VOID_TYPE.  */
11057
11058 bool
11059 validate_arglist (const_tree callexpr, ...)
11060 {
11061   enum tree_code code;
11062   bool res = 0;
11063   va_list ap;
11064   const_call_expr_arg_iterator iter;
11065   const_tree arg;
11066
11067   va_start (ap, callexpr);
11068   init_const_call_expr_arg_iterator (callexpr, &iter);
11069
11070   do
11071     {
11072       code = (enum tree_code) va_arg (ap, int);
11073       switch (code)
11074         {
11075         case 0:
11076           /* This signifies an ellipses, any further arguments are all ok.  */
11077           res = true;
11078           goto end;
11079         case VOID_TYPE:
11080           /* This signifies an endlink, if no arguments remain, return
11081              true, otherwise return false.  */
11082           res = !more_const_call_expr_args_p (&iter);
11083           goto end;
11084         default:
11085           /* If no parameters remain or the parameter's code does not
11086              match the specified code, return false.  Otherwise continue
11087              checking any remaining arguments.  */
11088           arg = next_const_call_expr_arg (&iter);
11089           if (!validate_arg (arg, code))
11090             goto end;
11091           break;
11092         }
11093     }
11094   while (1);
11095
11096   /* We need gotos here since we can only have one VA_CLOSE in a
11097      function.  */
11098  end: ;
11099   va_end (ap);
11100
11101   return res;
11102 }
11103
11104 /* Default target-specific builtin expander that does nothing.  */
11105
11106 rtx
11107 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11108                         rtx target ATTRIBUTE_UNUSED,
11109                         rtx subtarget ATTRIBUTE_UNUSED,
11110                         enum machine_mode mode ATTRIBUTE_UNUSED,
11111                         int ignore ATTRIBUTE_UNUSED)
11112 {
11113   return NULL_RTX;
11114 }
11115
11116 /* Returns true is EXP represents data that would potentially reside
11117    in a readonly section.  */
11118
11119 static bool
11120 readonly_data_expr (tree exp)
11121 {
11122   STRIP_NOPS (exp);
11123
11124   if (TREE_CODE (exp) != ADDR_EXPR)
11125     return false;
11126
11127   exp = get_base_address (TREE_OPERAND (exp, 0));
11128   if (!exp)
11129     return false;
11130
11131   /* Make sure we call decl_readonly_section only for trees it
11132      can handle (since it returns true for everything it doesn't
11133      understand).  */
11134   if (TREE_CODE (exp) == STRING_CST
11135       || TREE_CODE (exp) == CONSTRUCTOR
11136       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11137     return decl_readonly_section (exp, 0);
11138   else
11139     return false;
11140 }
11141
11142 /* Simplify a call to the strstr builtin.  S1 and S2 are the arguments
11143    to the call, and TYPE is its return type.
11144
11145    Return NULL_TREE if no simplification was possible, otherwise return the
11146    simplified form of the call as a tree.
11147
11148    The simplified form may be a constant or other expression which
11149    computes the same value, but in a more efficient manner (including
11150    calls to other builtin functions).
11151
11152    The call may contain arguments which need to be evaluated, but
11153    which are not useful to determine the result of the call.  In
11154    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11155    COMPOUND_EXPR will be an argument which must be evaluated.
11156    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11157    COMPOUND_EXPR in the chain will contain the tree for the simplified
11158    form of the builtin function call.  */
11159
11160 static tree
11161 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11162 {
11163   if (!validate_arg (s1, POINTER_TYPE)
11164       || !validate_arg (s2, POINTER_TYPE))
11165     return NULL_TREE;
11166   else
11167     {
11168       tree fn;
11169       const char *p1, *p2;
11170
11171       p2 = c_getstr (s2);
11172       if (p2 == NULL)
11173         return NULL_TREE;
11174
11175       p1 = c_getstr (s1);
11176       if (p1 != NULL)
11177         {
11178           const char *r = strstr (p1, p2);
11179           tree tem;
11180
11181           if (r == NULL)
11182             return build_int_cst (TREE_TYPE (s1), 0);
11183
11184           /* Return an offset into the constant string argument.  */
11185           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11186                              s1, size_int (r - p1));
11187           return fold_convert_loc (loc, type, tem);
11188         }
11189
11190       /* The argument is const char *, and the result is char *, so we need
11191          a type conversion here to avoid a warning.  */
11192       if (p2[0] == '\0')
11193         return fold_convert_loc (loc, type, s1);
11194
11195       if (p2[1] != '\0')
11196         return NULL_TREE;
11197
11198       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11199       if (!fn)
11200         return NULL_TREE;
11201
11202       /* New argument list transforming strstr(s1, s2) to
11203          strchr(s1, s2[0]).  */
11204       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11205     }
11206 }
11207
11208 /* Simplify a call to the strchr builtin.  S1 and S2 are the arguments to
11209    the call, and TYPE is its return type.
11210
11211    Return NULL_TREE if no simplification was possible, otherwise return the
11212    simplified form of the call as a tree.
11213
11214    The simplified form may be a constant or other expression which
11215    computes the same value, but in a more efficient manner (including
11216    calls to other builtin functions).
11217
11218    The call may contain arguments which need to be evaluated, but
11219    which are not useful to determine the result of the call.  In
11220    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11221    COMPOUND_EXPR will be an argument which must be evaluated.
11222    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11223    COMPOUND_EXPR in the chain will contain the tree for the simplified
11224    form of the builtin function call.  */
11225
11226 static tree
11227 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11228 {
11229   if (!validate_arg (s1, POINTER_TYPE)
11230       || !validate_arg (s2, INTEGER_TYPE))
11231     return NULL_TREE;
11232   else
11233     {
11234       const char *p1;
11235
11236       if (TREE_CODE (s2) != INTEGER_CST)
11237         return NULL_TREE;
11238
11239       p1 = c_getstr (s1);
11240       if (p1 != NULL)
11241         {
11242           char c;
11243           const char *r;
11244           tree tem;
11245
11246           if (target_char_cast (s2, &c))
11247             return NULL_TREE;
11248
11249           r = strchr (p1, c);
11250
11251           if (r == NULL)
11252             return build_int_cst (TREE_TYPE (s1), 0);
11253
11254           /* Return an offset into the constant string argument.  */
11255           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11256                              s1, size_int (r - p1));
11257           return fold_convert_loc (loc, type, tem);
11258         }
11259       return NULL_TREE;
11260     }
11261 }
11262
11263 /* Simplify a call to the strrchr builtin.  S1 and S2 are the arguments to
11264    the call, and TYPE is its return type.
11265
11266    Return NULL_TREE if no simplification was possible, otherwise return the
11267    simplified form of the call as a tree.
11268
11269    The simplified form may be a constant or other expression which
11270    computes the same value, but in a more efficient manner (including
11271    calls to other builtin functions).
11272
11273    The call may contain arguments which need to be evaluated, but
11274    which are not useful to determine the result of the call.  In
11275    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11276    COMPOUND_EXPR will be an argument which must be evaluated.
11277    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11278    COMPOUND_EXPR in the chain will contain the tree for the simplified
11279    form of the builtin function call.  */
11280
11281 static tree
11282 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11283 {
11284   if (!validate_arg (s1, POINTER_TYPE)
11285       || !validate_arg (s2, INTEGER_TYPE))
11286     return NULL_TREE;
11287   else
11288     {
11289       tree fn;
11290       const char *p1;
11291
11292       if (TREE_CODE (s2) != INTEGER_CST)
11293         return NULL_TREE;
11294
11295       p1 = c_getstr (s1);
11296       if (p1 != NULL)
11297         {
11298           char c;
11299           const char *r;
11300           tree tem;
11301
11302           if (target_char_cast (s2, &c))
11303             return NULL_TREE;
11304
11305           r = strrchr (p1, c);
11306
11307           if (r == NULL)
11308             return build_int_cst (TREE_TYPE (s1), 0);
11309
11310           /* Return an offset into the constant string argument.  */
11311           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11312                              s1, size_int (r - p1));
11313           return fold_convert_loc (loc, type, tem);
11314         }
11315
11316       if (! integer_zerop (s2))
11317         return NULL_TREE;
11318
11319       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11320       if (!fn)
11321         return NULL_TREE;
11322
11323       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
11324       return build_call_expr_loc (loc, fn, 2, s1, s2);
11325     }
11326 }
11327
11328 /* Simplify a call to the strpbrk builtin.  S1 and S2 are the arguments
11329    to the call, and TYPE is its return type.
11330
11331    Return NULL_TREE if no simplification was possible, otherwise return the
11332    simplified form of the call as a tree.
11333
11334    The simplified form may be a constant or other expression which
11335    computes the same value, but in a more efficient manner (including
11336    calls to other builtin functions).
11337
11338    The call may contain arguments which need to be evaluated, but
11339    which are not useful to determine the result of the call.  In
11340    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11341    COMPOUND_EXPR will be an argument which must be evaluated.
11342    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11343    COMPOUND_EXPR in the chain will contain the tree for the simplified
11344    form of the builtin function call.  */
11345
11346 static tree
11347 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11348 {
11349   if (!validate_arg (s1, POINTER_TYPE)
11350       || !validate_arg (s2, POINTER_TYPE))
11351     return NULL_TREE;
11352   else
11353     {
11354       tree fn;
11355       const char *p1, *p2;
11356
11357       p2 = c_getstr (s2);
11358       if (p2 == NULL)
11359         return NULL_TREE;
11360
11361       p1 = c_getstr (s1);
11362       if (p1 != NULL)
11363         {
11364           const char *r = strpbrk (p1, p2);
11365           tree tem;
11366
11367           if (r == NULL)
11368             return build_int_cst (TREE_TYPE (s1), 0);
11369
11370           /* Return an offset into the constant string argument.  */
11371           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11372                              s1, size_int (r - p1));
11373           return fold_convert_loc (loc, type, tem);
11374         }
11375
11376       if (p2[0] == '\0')
11377         /* strpbrk(x, "") == NULL.
11378            Evaluate and ignore s1 in case it had side-effects.  */
11379         return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11380
11381       if (p2[1] != '\0')
11382         return NULL_TREE;  /* Really call strpbrk.  */
11383
11384       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11385       if (!fn)
11386         return NULL_TREE;
11387
11388       /* New argument list transforming strpbrk(s1, s2) to
11389          strchr(s1, s2[0]).  */
11390       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11391     }
11392 }
11393
11394 /* Simplify a call to the strcat builtin.  DST and SRC are the arguments
11395    to the call.
11396
11397    Return NULL_TREE if no simplification was possible, otherwise return the
11398    simplified form of the call as a tree.
11399
11400    The simplified form may be a constant or other expression which
11401    computes the same value, but in a more efficient manner (including
11402    calls to other builtin functions).
11403
11404    The call may contain arguments which need to be evaluated, but
11405    which are not useful to determine the result of the call.  In
11406    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11407    COMPOUND_EXPR will be an argument which must be evaluated.
11408    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11409    COMPOUND_EXPR in the chain will contain the tree for the simplified
11410    form of the builtin function call.  */
11411
11412 static tree
11413 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11414 {
11415   if (!validate_arg (dst, POINTER_TYPE)
11416       || !validate_arg (src, POINTER_TYPE))
11417     return NULL_TREE;
11418   else
11419     {
11420       const char *p = c_getstr (src);
11421
11422       /* If the string length is zero, return the dst parameter.  */
11423       if (p && *p == '\0')
11424         return dst;
11425
11426       if (optimize_insn_for_speed_p ())
11427         {
11428           /* See if we can store by pieces into (dst + strlen(dst)).  */
11429           tree newdst, call;
11430           tree strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11431           tree strcpy_fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11432
11433           if (!strlen_fn || !strcpy_fn)
11434             return NULL_TREE;
11435
11436           /* If we don't have a movstr we don't want to emit an strcpy
11437              call.  We have to do that if the length of the source string
11438              isn't computable (in that case we can use memcpy probably
11439              later expanding to a sequence of mov instructions).  If we
11440              have movstr instructions we can emit strcpy calls.  */
11441           if (!HAVE_movstr)
11442             {
11443               tree len = c_strlen (src, 1);
11444               if (! len || TREE_SIDE_EFFECTS (len))
11445                 return NULL_TREE;
11446             }
11447
11448           /* Stabilize the argument list.  */
11449           dst = builtin_save_expr (dst);
11450
11451           /* Create strlen (dst).  */
11452           newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11453           /* Create (dst p+ strlen (dst)).  */
11454
11455           newdst = fold_build2_loc (loc, POINTER_PLUS_EXPR,
11456                                 TREE_TYPE (dst), dst, newdst);
11457           newdst = builtin_save_expr (newdst);
11458
11459           call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11460           return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11461         }
11462       return NULL_TREE;
11463     }
11464 }
11465
11466 /* Simplify a call to the strncat builtin.  DST, SRC, and LEN are the
11467    arguments to the call.
11468
11469    Return NULL_TREE if no simplification was possible, otherwise return the
11470    simplified form of the call as a tree.
11471
11472    The simplified form may be a constant or other expression which
11473    computes the same value, but in a more efficient manner (including
11474    calls to other builtin functions).
11475
11476    The call may contain arguments which need to be evaluated, but
11477    which are not useful to determine the result of the call.  In
11478    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11479    COMPOUND_EXPR will be an argument which must be evaluated.
11480    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11481    COMPOUND_EXPR in the chain will contain the tree for the simplified
11482    form of the builtin function call.  */
11483
11484 static tree
11485 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11486 {
11487   if (!validate_arg (dst, POINTER_TYPE)
11488       || !validate_arg (src, POINTER_TYPE)
11489       || !validate_arg (len, INTEGER_TYPE))
11490     return NULL_TREE;
11491   else
11492     {
11493       const char *p = c_getstr (src);
11494
11495       /* If the requested length is zero, or the src parameter string
11496          length is zero, return the dst parameter.  */
11497       if (integer_zerop (len) || (p && *p == '\0'))
11498         return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11499
11500       /* If the requested len is greater than or equal to the string
11501          length, call strcat.  */
11502       if (TREE_CODE (len) == INTEGER_CST && p
11503           && compare_tree_int (len, strlen (p)) >= 0)
11504         {
11505           tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
11506
11507           /* If the replacement _DECL isn't initialized, don't do the
11508              transformation.  */
11509           if (!fn)
11510             return NULL_TREE;
11511
11512           return build_call_expr_loc (loc, fn, 2, dst, src);
11513         }
11514       return NULL_TREE;
11515     }
11516 }
11517
11518 /* Simplify a call to the strspn builtin.  S1 and S2 are the arguments
11519    to the call.
11520
11521    Return NULL_TREE if no simplification was possible, otherwise return the
11522    simplified form of the call as a tree.
11523
11524    The simplified form may be a constant or other expression which
11525    computes the same value, but in a more efficient manner (including
11526    calls to other builtin functions).
11527
11528    The call may contain arguments which need to be evaluated, but
11529    which are not useful to determine the result of the call.  In
11530    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11531    COMPOUND_EXPR will be an argument which must be evaluated.
11532    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11533    COMPOUND_EXPR in the chain will contain the tree for the simplified
11534    form of the builtin function call.  */
11535
11536 static tree
11537 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11538 {
11539   if (!validate_arg (s1, POINTER_TYPE)
11540       || !validate_arg (s2, POINTER_TYPE))
11541     return NULL_TREE;
11542   else
11543     {
11544       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11545
11546       /* If both arguments are constants, evaluate at compile-time.  */
11547       if (p1 && p2)
11548         {
11549           const size_t r = strspn (p1, p2);
11550           return size_int (r);
11551         }
11552
11553       /* If either argument is "", return NULL_TREE.  */
11554       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11555         /* Evaluate and ignore both arguments in case either one has
11556            side-effects.  */
11557         return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11558                                   s1, s2);
11559       return NULL_TREE;
11560     }
11561 }
11562
11563 /* Simplify a call to the strcspn builtin.  S1 and S2 are the arguments
11564    to the call.
11565
11566    Return NULL_TREE if no simplification was possible, otherwise return the
11567    simplified form of the call as a tree.
11568
11569    The simplified form may be a constant or other expression which
11570    computes the same value, but in a more efficient manner (including
11571    calls to other builtin functions).
11572
11573    The call may contain arguments which need to be evaluated, but
11574    which are not useful to determine the result of the call.  In
11575    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11576    COMPOUND_EXPR will be an argument which must be evaluated.
11577    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11578    COMPOUND_EXPR in the chain will contain the tree for the simplified
11579    form of the builtin function call.  */
11580
11581 static tree
11582 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11583 {
11584   if (!validate_arg (s1, POINTER_TYPE)
11585       || !validate_arg (s2, POINTER_TYPE))
11586     return NULL_TREE;
11587   else
11588     {
11589       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11590
11591       /* If both arguments are constants, evaluate at compile-time.  */
11592       if (p1 && p2)
11593         {
11594           const size_t r = strcspn (p1, p2);
11595           return size_int (r);
11596         }
11597
11598       /* If the first argument is "", return NULL_TREE.  */
11599       if (p1 && *p1 == '\0')
11600         {
11601           /* Evaluate and ignore argument s2 in case it has
11602              side-effects.  */
11603           return omit_one_operand_loc (loc, size_type_node,
11604                                    size_zero_node, s2);
11605         }
11606
11607       /* If the second argument is "", return __builtin_strlen(s1).  */
11608       if (p2 && *p2 == '\0')
11609         {
11610           tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11611
11612           /* If the replacement _DECL isn't initialized, don't do the
11613              transformation.  */
11614           if (!fn)
11615             return NULL_TREE;
11616
11617           return build_call_expr_loc (loc, fn, 1, s1);
11618         }
11619       return NULL_TREE;
11620     }
11621 }
11622
11623 /* Fold a call to the fputs builtin.  ARG0 and ARG1 are the arguments
11624    to the call.  IGNORE is true if the value returned
11625    by the builtin will be ignored.  UNLOCKED is true is true if this
11626    actually a call to fputs_unlocked.  If LEN in non-NULL, it represents
11627    the known length of the string.  Return NULL_TREE if no simplification
11628    was possible.  */
11629
11630 tree
11631 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
11632                     bool ignore, bool unlocked, tree len)
11633 {
11634   /* If we're using an unlocked function, assume the other unlocked
11635      functions exist explicitly.  */
11636   tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
11637     : implicit_built_in_decls[BUILT_IN_FPUTC];
11638   tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
11639     : implicit_built_in_decls[BUILT_IN_FWRITE];
11640
11641   /* If the return value is used, don't do the transformation.  */
11642   if (!ignore)
11643     return NULL_TREE;
11644
11645   /* Verify the arguments in the original call.  */
11646   if (!validate_arg (arg0, POINTER_TYPE)
11647       || !validate_arg (arg1, POINTER_TYPE))
11648     return NULL_TREE;
11649
11650   if (! len)
11651     len = c_strlen (arg0, 0);
11652
11653   /* Get the length of the string passed to fputs.  If the length
11654      can't be determined, punt.  */
11655   if (!len
11656       || TREE_CODE (len) != INTEGER_CST)
11657     return NULL_TREE;
11658
11659   switch (compare_tree_int (len, 1))
11660     {
11661     case -1: /* length is 0, delete the call entirely .  */
11662       return omit_one_operand_loc (loc, integer_type_node,
11663                                integer_zero_node, arg1);;
11664
11665     case 0: /* length is 1, call fputc.  */
11666       {
11667         const char *p = c_getstr (arg0);
11668
11669         if (p != NULL)
11670           {
11671             if (fn_fputc)
11672               return build_call_expr_loc (loc, fn_fputc, 2,
11673                                       build_int_cst (NULL_TREE, p[0]), arg1);
11674             else
11675               return NULL_TREE;
11676           }
11677       }
11678       /* FALLTHROUGH */
11679     case 1: /* length is greater than 1, call fwrite.  */
11680       {
11681         /* If optimizing for size keep fputs.  */
11682         if (optimize_function_for_size_p (cfun))
11683           return NULL_TREE;
11684         /* New argument list transforming fputs(string, stream) to
11685            fwrite(string, 1, len, stream).  */
11686         if (fn_fwrite)
11687           return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
11688                                   size_one_node, len, arg1);
11689         else
11690           return NULL_TREE;
11691       }
11692     default:
11693       gcc_unreachable ();
11694     }
11695   return NULL_TREE;
11696 }
11697
11698 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11699    produced.  False otherwise.  This is done so that we don't output the error
11700    or warning twice or three times.  */
11701
11702 bool
11703 fold_builtin_next_arg (tree exp, bool va_start_p)
11704 {
11705   tree fntype = TREE_TYPE (current_function_decl);
11706   int nargs = call_expr_nargs (exp);
11707   tree arg;
11708
11709   if (!stdarg_p (fntype))
11710     {
11711       error ("%<va_start%> used in function with fixed args");
11712       return true;
11713     }
11714
11715   if (va_start_p)
11716     {
11717       if (va_start_p && (nargs != 2))
11718         {
11719           error ("wrong number of arguments to function %<va_start%>");
11720           return true;
11721         }
11722       arg = CALL_EXPR_ARG (exp, 1);
11723     }
11724   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11725      when we checked the arguments and if needed issued a warning.  */
11726   else
11727     {
11728       if (nargs == 0)
11729         {
11730           /* Evidently an out of date version of <stdarg.h>; can't validate
11731              va_start's second argument, but can still work as intended.  */
11732           warning (0, "%<__builtin_next_arg%> called without an argument");
11733           return true;
11734         }
11735       else if (nargs > 1)
11736         {
11737           error ("wrong number of arguments to function %<__builtin_next_arg%>");
11738           return true;
11739         }
11740       arg = CALL_EXPR_ARG (exp, 0);
11741     }
11742
11743   if (TREE_CODE (arg) == SSA_NAME)
11744     arg = SSA_NAME_VAR (arg);
11745
11746   /* We destructively modify the call to be __builtin_va_start (ap, 0)
11747      or __builtin_next_arg (0) the first time we see it, after checking
11748      the arguments and if needed issuing a warning.  */
11749   if (!integer_zerop (arg))
11750     {
11751       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
11752
11753       /* Strip off all nops for the sake of the comparison.  This
11754          is not quite the same as STRIP_NOPS.  It does more.
11755          We must also strip off INDIRECT_EXPR for C++ reference
11756          parameters.  */
11757       while (CONVERT_EXPR_P (arg)
11758              || TREE_CODE (arg) == INDIRECT_REF)
11759         arg = TREE_OPERAND (arg, 0);
11760       if (arg != last_parm)
11761         {
11762           /* FIXME: Sometimes with the tree optimizers we can get the
11763              not the last argument even though the user used the last
11764              argument.  We just warn and set the arg to be the last
11765              argument so that we will get wrong-code because of
11766              it.  */
11767           warning (0, "second parameter of %<va_start%> not last named argument");
11768         }
11769
11770       /* Undefined by C99 7.15.1.4p4 (va_start):
11771          "If the parameter parmN is declared with the register storage
11772          class, with a function or array type, or with a type that is
11773          not compatible with the type that results after application of
11774          the default argument promotions, the behavior is undefined."
11775       */
11776       else if (DECL_REGISTER (arg))
11777         warning (0, "undefined behaviour when second parameter of "
11778                  "%<va_start%> is declared with %<register%> storage");
11779
11780       /* We want to verify the second parameter just once before the tree
11781          optimizers are run and then avoid keeping it in the tree,
11782          as otherwise we could warn even for correct code like:
11783          void foo (int i, ...)
11784          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
11785       if (va_start_p)
11786         CALL_EXPR_ARG (exp, 1) = integer_zero_node;
11787       else
11788         CALL_EXPR_ARG (exp, 0) = integer_zero_node;
11789     }
11790   return false;
11791 }
11792
11793
11794 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11795    ORIG may be null if this is a 2-argument call.  We don't attempt to
11796    simplify calls with more than 3 arguments.
11797
11798    Return NULL_TREE if no simplification was possible, otherwise return the
11799    simplified form of the call as a tree.  If IGNORED is true, it means that
11800    the caller does not use the returned value of the function.  */
11801
11802 static tree
11803 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
11804                       tree orig, int ignored)
11805 {
11806   tree call, retval;
11807   const char *fmt_str = NULL;
11808
11809   /* Verify the required arguments in the original call.  We deal with two
11810      types of sprintf() calls: 'sprintf (str, fmt)' and
11811      'sprintf (dest, "%s", orig)'.  */
11812   if (!validate_arg (dest, POINTER_TYPE)
11813       || !validate_arg (fmt, POINTER_TYPE))
11814     return NULL_TREE;
11815   if (orig && !validate_arg (orig, POINTER_TYPE))
11816     return NULL_TREE;
11817
11818   /* Check whether the format is a literal string constant.  */
11819   fmt_str = c_getstr (fmt);
11820   if (fmt_str == NULL)
11821     return NULL_TREE;
11822
11823   call = NULL_TREE;
11824   retval = NULL_TREE;
11825
11826   if (!init_target_chars ())
11827     return NULL_TREE;
11828
11829   /* If the format doesn't contain % args or %%, use strcpy.  */
11830   if (strchr (fmt_str, target_percent) == NULL)
11831     {
11832       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11833
11834       if (!fn)
11835         return NULL_TREE;
11836
11837       /* Don't optimize sprintf (buf, "abc", ptr++).  */
11838       if (orig)
11839         return NULL_TREE;
11840
11841       /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11842          'format' is known to contain no % formats.  */
11843       call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11844       if (!ignored)
11845         retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11846     }
11847
11848   /* If the format is "%s", use strcpy if the result isn't used.  */
11849   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11850     {
11851       tree fn;
11852       fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11853
11854       if (!fn)
11855         return NULL_TREE;
11856
11857       /* Don't crash on sprintf (str1, "%s").  */
11858       if (!orig)
11859         return NULL_TREE;
11860
11861       /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2).  */
11862       if (!ignored)
11863         {
11864           retval = c_strlen (orig, 1);
11865           if (!retval || TREE_CODE (retval) != INTEGER_CST)
11866             return NULL_TREE;
11867         }
11868       call = build_call_expr_loc (loc, fn, 2, dest, orig);
11869     }
11870
11871   if (call && retval)
11872     {
11873       retval = fold_convert_loc
11874         (loc, TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
11875          retval);
11876       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11877     }
11878   else
11879     return call;
11880 }
11881
11882 /* Simplify a call to the snprintf builtin with arguments DEST, DESTSIZE,
11883    FMT, and ORIG.  ORIG may be null if this is a 3-argument call.  We don't
11884    attempt to simplify calls with more than 4 arguments.
11885
11886    Return NULL_TREE if no simplification was possible, otherwise return the
11887    simplified form of the call as a tree.  If IGNORED is true, it means that
11888    the caller does not use the returned value of the function.  */
11889
11890 static tree
11891 fold_builtin_snprintf (location_t loc, tree dest, tree destsize, tree fmt,
11892                        tree orig, int ignored)
11893 {
11894   tree call, retval;
11895   const char *fmt_str = NULL;
11896   unsigned HOST_WIDE_INT destlen;
11897
11898   /* Verify the required arguments in the original call.  We deal with two
11899      types of snprintf() calls: 'snprintf (str, cst, fmt)' and
11900      'snprintf (dest, cst, "%s", orig)'.  */
11901   if (!validate_arg (dest, POINTER_TYPE)
11902       || !validate_arg (destsize, INTEGER_TYPE)
11903       || !validate_arg (fmt, POINTER_TYPE))
11904     return NULL_TREE;
11905   if (orig && !validate_arg (orig, POINTER_TYPE))
11906     return NULL_TREE;
11907
11908   if (!host_integerp (destsize, 1))
11909     return NULL_TREE;
11910
11911   /* Check whether the format is a literal string constant.  */
11912   fmt_str = c_getstr (fmt);
11913   if (fmt_str == NULL)
11914     return NULL_TREE;
11915
11916   call = NULL_TREE;
11917   retval = NULL_TREE;
11918
11919   if (!init_target_chars ())
11920     return NULL_TREE;
11921
11922   destlen = tree_low_cst (destsize, 1);
11923
11924   /* If the format doesn't contain % args or %%, use strcpy.  */
11925   if (strchr (fmt_str, target_percent) == NULL)
11926     {
11927       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11928       size_t len = strlen (fmt_str);
11929
11930       /* Don't optimize snprintf (buf, 4, "abc", ptr++).  */
11931       if (orig)
11932         return NULL_TREE;
11933
11934       /* We could expand this as
11935          memcpy (str, fmt, cst - 1); str[cst - 1] = '\0';
11936          or to
11937          memcpy (str, fmt_with_nul_at_cstm1, cst);
11938          but in the former case that might increase code size
11939          and in the latter case grow .rodata section too much.
11940          So punt for now.  */
11941       if (len >= destlen)
11942         return NULL_TREE;
11943
11944       if (!fn)
11945         return NULL_TREE;
11946
11947       /* Convert snprintf (str, cst, fmt) into strcpy (str, fmt) when
11948          'format' is known to contain no % formats and
11949          strlen (fmt) < cst.  */
11950       call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11951
11952       if (!ignored)
11953         retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11954     }
11955
11956   /* If the format is "%s", use strcpy if the result isn't used.  */
11957   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11958     {
11959       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11960       unsigned HOST_WIDE_INT origlen;
11961
11962       /* Don't crash on snprintf (str1, cst, "%s").  */
11963       if (!orig)
11964         return NULL_TREE;
11965
11966       retval = c_strlen (orig, 1);
11967       if (!retval || !host_integerp (retval, 1))
11968         return NULL_TREE;
11969
11970       origlen = tree_low_cst (retval, 1);
11971       /* We could expand this as
11972          memcpy (str1, str2, cst - 1); str1[cst - 1] = '\0';
11973          or to
11974          memcpy (str1, str2_with_nul_at_cstm1, cst);
11975          but in the former case that might increase code size
11976          and in the latter case grow .rodata section too much.
11977          So punt for now.  */
11978       if (origlen >= destlen)
11979         return NULL_TREE;
11980
11981       /* Convert snprintf (str1, cst, "%s", str2) into
11982          strcpy (str1, str2) if strlen (str2) < cst.  */
11983       if (!fn)
11984         return NULL_TREE;
11985
11986       call = build_call_expr_loc (loc, fn, 2, dest, orig);
11987
11988       if (ignored)
11989         retval = NULL_TREE;
11990     }
11991
11992   if (call && retval)
11993     {
11994       tree fn = built_in_decls[BUILT_IN_SNPRINTF];
11995       retval = fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fn)), retval);
11996       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11997     }
11998   else
11999     return call;
12000 }
12001
12002 /* Expand a call EXP to __builtin_object_size.  */
12003
12004 rtx
12005 expand_builtin_object_size (tree exp)
12006 {
12007   tree ost;
12008   int object_size_type;
12009   tree fndecl = get_callee_fndecl (exp);
12010
12011   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
12012     {
12013       error ("%Kfirst argument of %D must be a pointer, second integer constant",
12014              exp, fndecl);
12015       expand_builtin_trap ();
12016       return const0_rtx;
12017     }
12018
12019   ost = CALL_EXPR_ARG (exp, 1);
12020   STRIP_NOPS (ost);
12021
12022   if (TREE_CODE (ost) != INTEGER_CST
12023       || tree_int_cst_sgn (ost) < 0
12024       || compare_tree_int (ost, 3) > 0)
12025     {
12026       error ("%Klast argument of %D is not integer constant between 0 and 3",
12027              exp, fndecl);
12028       expand_builtin_trap ();
12029       return const0_rtx;
12030     }
12031
12032   object_size_type = tree_low_cst (ost, 0);
12033
12034   return object_size_type < 2 ? constm1_rtx : const0_rtx;
12035 }
12036
12037 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12038    FCODE is the BUILT_IN_* to use.
12039    Return NULL_RTX if we failed; the caller should emit a normal call,
12040    otherwise try to get the result in TARGET, if convenient (and in
12041    mode MODE if that's convenient).  */
12042
12043 static rtx
12044 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
12045                            enum built_in_function fcode)
12046 {
12047   tree dest, src, len, size;
12048
12049   if (!validate_arglist (exp,
12050                          POINTER_TYPE,
12051                          fcode == BUILT_IN_MEMSET_CHK
12052                          ? INTEGER_TYPE : POINTER_TYPE,
12053                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
12054     return NULL_RTX;
12055
12056   dest = CALL_EXPR_ARG (exp, 0);
12057   src = CALL_EXPR_ARG (exp, 1);
12058   len = CALL_EXPR_ARG (exp, 2);
12059   size = CALL_EXPR_ARG (exp, 3);
12060
12061   if (! host_integerp (size, 1))
12062     return NULL_RTX;
12063
12064   if (host_integerp (len, 1) || integer_all_onesp (size))
12065     {
12066       tree fn;
12067
12068       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
12069         {
12070           warning_at (tree_nonartificial_location (exp),
12071                       0, "%Kcall to %D will always overflow destination buffer",
12072                       exp, get_callee_fndecl (exp));
12073           return NULL_RTX;
12074         }
12075
12076       fn = NULL_TREE;
12077       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12078          mem{cpy,pcpy,move,set} is available.  */
12079       switch (fcode)
12080         {
12081         case BUILT_IN_MEMCPY_CHK:
12082           fn = built_in_decls[BUILT_IN_MEMCPY];
12083           break;
12084         case BUILT_IN_MEMPCPY_CHK:
12085           fn = built_in_decls[BUILT_IN_MEMPCPY];
12086           break;
12087         case BUILT_IN_MEMMOVE_CHK:
12088           fn = built_in_decls[BUILT_IN_MEMMOVE];
12089           break;
12090         case BUILT_IN_MEMSET_CHK:
12091           fn = built_in_decls[BUILT_IN_MEMSET];
12092           break;
12093         default:
12094           break;
12095         }
12096
12097       if (! fn)
12098         return NULL_RTX;
12099
12100       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
12101       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12102       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12103       return expand_expr (fn, target, mode, EXPAND_NORMAL);
12104     }
12105   else if (fcode == BUILT_IN_MEMSET_CHK)
12106     return NULL_RTX;
12107   else
12108     {
12109       unsigned int dest_align
12110         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
12111
12112       /* If DEST is not a pointer type, call the normal function.  */
12113       if (dest_align == 0)
12114         return NULL_RTX;
12115
12116       /* If SRC and DEST are the same (and not volatile), do nothing.  */
12117       if (operand_equal_p (src, dest, 0))
12118         {
12119           tree expr;
12120
12121           if (fcode != BUILT_IN_MEMPCPY_CHK)
12122             {
12123               /* Evaluate and ignore LEN in case it has side-effects.  */
12124               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
12125               return expand_expr (dest, target, mode, EXPAND_NORMAL);
12126             }
12127
12128           expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
12129           return expand_expr (expr, target, mode, EXPAND_NORMAL);
12130         }
12131
12132       /* __memmove_chk special case.  */
12133       if (fcode == BUILT_IN_MEMMOVE_CHK)
12134         {
12135           unsigned int src_align
12136             = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
12137
12138           if (src_align == 0)
12139             return NULL_RTX;
12140
12141           /* If src is categorized for a readonly section we can use
12142              normal __memcpy_chk.  */
12143           if (readonly_data_expr (src))
12144             {
12145               tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12146               if (!fn)
12147                 return NULL_RTX;
12148               fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
12149                                           dest, src, len, size);
12150               gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12151               CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12152               return expand_expr (fn, target, mode, EXPAND_NORMAL);
12153             }
12154         }
12155       return NULL_RTX;
12156     }
12157 }
12158
12159 /* Emit warning if a buffer overflow is detected at compile time.  */
12160
12161 static void
12162 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
12163 {
12164   int is_strlen = 0;
12165   tree len, size;
12166   location_t loc = tree_nonartificial_location (exp);
12167
12168   switch (fcode)
12169     {
12170     case BUILT_IN_STRCPY_CHK:
12171     case BUILT_IN_STPCPY_CHK:
12172     /* For __strcat_chk the warning will be emitted only if overflowing
12173        by at least strlen (dest) + 1 bytes.  */
12174     case BUILT_IN_STRCAT_CHK:
12175       len = CALL_EXPR_ARG (exp, 1);
12176       size = CALL_EXPR_ARG (exp, 2);
12177       is_strlen = 1;
12178       break;
12179     case BUILT_IN_STRNCAT_CHK:
12180     case BUILT_IN_STRNCPY_CHK:
12181       len = CALL_EXPR_ARG (exp, 2);
12182       size = CALL_EXPR_ARG (exp, 3);
12183       break;
12184     case BUILT_IN_SNPRINTF_CHK:
12185     case BUILT_IN_VSNPRINTF_CHK:
12186       len = CALL_EXPR_ARG (exp, 1);
12187       size = CALL_EXPR_ARG (exp, 3);
12188       break;
12189     default:
12190       gcc_unreachable ();
12191     }
12192
12193   if (!len || !size)
12194     return;
12195
12196   if (! host_integerp (size, 1) || integer_all_onesp (size))
12197     return;
12198
12199   if (is_strlen)
12200     {
12201       len = c_strlen (len, 1);
12202       if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12203         return;
12204     }
12205   else if (fcode == BUILT_IN_STRNCAT_CHK)
12206     {
12207       tree src = CALL_EXPR_ARG (exp, 1);
12208       if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12209         return;
12210       src = c_strlen (src, 1);
12211       if (! src || ! host_integerp (src, 1))
12212         {
12213           warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12214                       exp, get_callee_fndecl (exp));
12215           return;
12216         }
12217       else if (tree_int_cst_lt (src, size))
12218         return;
12219     }
12220   else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12221     return;
12222
12223   warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12224               exp, get_callee_fndecl (exp));
12225 }
12226
12227 /* Emit warning if a buffer overflow is detected at compile time
12228    in __sprintf_chk/__vsprintf_chk calls.  */
12229
12230 static void
12231 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12232 {
12233   tree size, len, fmt;
12234   const char *fmt_str;
12235   int nargs = call_expr_nargs (exp);
12236
12237   /* Verify the required arguments in the original call.  */
12238
12239   if (nargs < 4)
12240     return;
12241   size = CALL_EXPR_ARG (exp, 2);
12242   fmt = CALL_EXPR_ARG (exp, 3);
12243
12244   if (! host_integerp (size, 1) || integer_all_onesp (size))
12245     return;
12246
12247   /* Check whether the format is a literal string constant.  */
12248   fmt_str = c_getstr (fmt);
12249   if (fmt_str == NULL)
12250     return;
12251
12252   if (!init_target_chars ())
12253     return;
12254
12255   /* If the format doesn't contain % args or %%, we know its size.  */
12256   if (strchr (fmt_str, target_percent) == 0)
12257     len = build_int_cstu (size_type_node, strlen (fmt_str));
12258   /* If the format is "%s" and first ... argument is a string literal,
12259      we know it too.  */
12260   else if (fcode == BUILT_IN_SPRINTF_CHK
12261            && strcmp (fmt_str, target_percent_s) == 0)
12262     {
12263       tree arg;
12264
12265       if (nargs < 5)
12266         return;
12267       arg = CALL_EXPR_ARG (exp, 4);
12268       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12269         return;
12270
12271       len = c_strlen (arg, 1);
12272       if (!len || ! host_integerp (len, 1))
12273         return;
12274     }
12275   else
12276     return;
12277
12278   if (! tree_int_cst_lt (len, size))
12279     warning_at (tree_nonartificial_location (exp),
12280                 0, "%Kcall to %D will always overflow destination buffer",
12281                 exp, get_callee_fndecl (exp));
12282 }
12283
12284 /* Emit warning if a free is called with address of a variable.  */
12285
12286 static void
12287 maybe_emit_free_warning (tree exp)
12288 {
12289   tree arg = CALL_EXPR_ARG (exp, 0);
12290
12291   STRIP_NOPS (arg);
12292   if (TREE_CODE (arg) != ADDR_EXPR)
12293     return;
12294
12295   arg = get_base_address (TREE_OPERAND (arg, 0));
12296   if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
12297     return;
12298
12299   if (SSA_VAR_P (arg))
12300     warning_at (tree_nonartificial_location (exp),
12301                 0, "%Kattempt to free a non-heap object %qD", exp, arg);
12302   else
12303     warning_at (tree_nonartificial_location (exp),
12304                 0, "%Kattempt to free a non-heap object", exp);
12305 }
12306
12307 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12308    if possible.  */
12309
12310 tree
12311 fold_builtin_object_size (tree ptr, tree ost)
12312 {
12313   unsigned HOST_WIDE_INT bytes;
12314   int object_size_type;
12315
12316   if (!validate_arg (ptr, POINTER_TYPE)
12317       || !validate_arg (ost, INTEGER_TYPE))
12318     return NULL_TREE;
12319
12320   STRIP_NOPS (ost);
12321
12322   if (TREE_CODE (ost) != INTEGER_CST
12323       || tree_int_cst_sgn (ost) < 0
12324       || compare_tree_int (ost, 3) > 0)
12325     return NULL_TREE;
12326
12327   object_size_type = tree_low_cst (ost, 0);
12328
12329   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12330      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12331      and (size_t) 0 for types 2 and 3.  */
12332   if (TREE_SIDE_EFFECTS (ptr))
12333     return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12334
12335   if (TREE_CODE (ptr) == ADDR_EXPR)
12336     {
12337       bytes = compute_builtin_object_size (ptr, object_size_type);
12338       if (double_int_fits_to_tree_p (size_type_node,
12339                                      uhwi_to_double_int (bytes)))
12340         return build_int_cstu (size_type_node, bytes);
12341     }
12342   else if (TREE_CODE (ptr) == SSA_NAME)
12343     {
12344       /* If object size is not known yet, delay folding until
12345        later.  Maybe subsequent passes will help determining
12346        it.  */
12347       bytes = compute_builtin_object_size (ptr, object_size_type);
12348       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
12349           && double_int_fits_to_tree_p (size_type_node,
12350                                         uhwi_to_double_int (bytes)))
12351         return build_int_cstu (size_type_node, bytes);
12352     }
12353
12354   return NULL_TREE;
12355 }
12356
12357 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12358    DEST, SRC, LEN, and SIZE are the arguments to the call.
12359    IGNORE is true, if return value can be ignored.  FCODE is the BUILT_IN_*
12360    code of the builtin.  If MAXLEN is not NULL, it is maximum length
12361    passed as third argument.  */
12362
12363 tree
12364 fold_builtin_memory_chk (location_t loc, tree fndecl,
12365                          tree dest, tree src, tree len, tree size,
12366                          tree maxlen, bool ignore,
12367                          enum built_in_function fcode)
12368 {
12369   tree fn;
12370
12371   if (!validate_arg (dest, POINTER_TYPE)
12372       || !validate_arg (src,
12373                         (fcode == BUILT_IN_MEMSET_CHK
12374                          ? INTEGER_TYPE : POINTER_TYPE))
12375       || !validate_arg (len, INTEGER_TYPE)
12376       || !validate_arg (size, INTEGER_TYPE))
12377     return NULL_TREE;
12378
12379   /* If SRC and DEST are the same (and not volatile), return DEST
12380      (resp. DEST+LEN for __mempcpy_chk).  */
12381   if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12382     {
12383       if (fcode != BUILT_IN_MEMPCPY_CHK)
12384         return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12385                                  dest, len);
12386       else
12387         {
12388           tree temp = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest),
12389                                    dest, len);
12390           return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12391         }
12392     }
12393
12394   if (! host_integerp (size, 1))
12395     return NULL_TREE;
12396
12397   if (! integer_all_onesp (size))
12398     {
12399       if (! host_integerp (len, 1))
12400         {
12401           /* If LEN is not constant, try MAXLEN too.
12402              For MAXLEN only allow optimizing into non-_ocs function
12403              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12404           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12405             {
12406               if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12407                 {
12408                   /* (void) __mempcpy_chk () can be optimized into
12409                      (void) __memcpy_chk ().  */
12410                   fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12411                   if (!fn)
12412                     return NULL_TREE;
12413
12414                   return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12415                 }
12416               return NULL_TREE;
12417             }
12418         }
12419       else
12420         maxlen = len;
12421
12422       if (tree_int_cst_lt (size, maxlen))
12423         return NULL_TREE;
12424     }
12425
12426   fn = NULL_TREE;
12427   /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12428      mem{cpy,pcpy,move,set} is available.  */
12429   switch (fcode)
12430     {
12431     case BUILT_IN_MEMCPY_CHK:
12432       fn = built_in_decls[BUILT_IN_MEMCPY];
12433       break;
12434     case BUILT_IN_MEMPCPY_CHK:
12435       fn = built_in_decls[BUILT_IN_MEMPCPY];
12436       break;
12437     case BUILT_IN_MEMMOVE_CHK:
12438       fn = built_in_decls[BUILT_IN_MEMMOVE];
12439       break;
12440     case BUILT_IN_MEMSET_CHK:
12441       fn = built_in_decls[BUILT_IN_MEMSET];
12442       break;
12443     default:
12444       break;
12445     }
12446
12447   if (!fn)
12448     return NULL_TREE;
12449
12450   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12451 }
12452
12453 /* Fold a call to the __st[rp]cpy_chk builtin.
12454    DEST, SRC, and SIZE are the arguments to the call.
12455    IGNORE is true if return value can be ignored.  FCODE is the BUILT_IN_*
12456    code of the builtin.  If MAXLEN is not NULL, it is maximum length of
12457    strings passed as second argument.  */
12458
12459 tree
12460 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12461                          tree src, tree size,
12462                          tree maxlen, bool ignore,
12463                          enum built_in_function fcode)
12464 {
12465   tree len, fn;
12466
12467   if (!validate_arg (dest, POINTER_TYPE)
12468       || !validate_arg (src, POINTER_TYPE)
12469       || !validate_arg (size, INTEGER_TYPE))
12470     return NULL_TREE;
12471
12472   /* If SRC and DEST are the same (and not volatile), return DEST.  */
12473   if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12474     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12475
12476   if (! host_integerp (size, 1))
12477     return NULL_TREE;
12478
12479   if (! integer_all_onesp (size))
12480     {
12481       len = c_strlen (src, 1);
12482       if (! len || ! host_integerp (len, 1))
12483         {
12484           /* If LEN is not constant, try MAXLEN too.
12485              For MAXLEN only allow optimizing into non-_ocs function
12486              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12487           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12488             {
12489               if (fcode == BUILT_IN_STPCPY_CHK)
12490                 {
12491                   if (! ignore)
12492                     return NULL_TREE;
12493
12494                   /* If return value of __stpcpy_chk is ignored,
12495                      optimize into __strcpy_chk.  */
12496                   fn = built_in_decls[BUILT_IN_STRCPY_CHK];
12497                   if (!fn)
12498                     return NULL_TREE;
12499
12500                   return build_call_expr_loc (loc, fn, 3, dest, src, size);
12501                 }
12502
12503               if (! len || TREE_SIDE_EFFECTS (len))
12504                 return NULL_TREE;
12505
12506               /* If c_strlen returned something, but not a constant,
12507                  transform __strcpy_chk into __memcpy_chk.  */
12508               fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12509               if (!fn)
12510                 return NULL_TREE;
12511
12512               len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
12513               return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12514                                        build_call_expr_loc (loc, fn, 4,
12515                                                         dest, src, len, size));
12516             }
12517         }
12518       else
12519         maxlen = len;
12520
12521       if (! tree_int_cst_lt (maxlen, size))
12522         return NULL_TREE;
12523     }
12524
12525   /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available.  */
12526   fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
12527                       ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
12528   if (!fn)
12529     return NULL_TREE;
12530
12531   return build_call_expr_loc (loc, fn, 2, dest, src);
12532 }
12533
12534 /* Fold a call to the __strncpy_chk builtin.  DEST, SRC, LEN, and SIZE
12535    are the arguments to the call.  If MAXLEN is not NULL, it is maximum
12536    length passed as third argument.  */
12537
12538 tree
12539 fold_builtin_strncpy_chk (location_t loc, tree dest, tree src,
12540                           tree len, tree size, tree maxlen)
12541 {
12542   tree fn;
12543
12544   if (!validate_arg (dest, POINTER_TYPE)
12545       || !validate_arg (src, POINTER_TYPE)
12546       || !validate_arg (len, INTEGER_TYPE)
12547       || !validate_arg (size, INTEGER_TYPE))
12548     return NULL_TREE;
12549
12550   if (! host_integerp (size, 1))
12551     return NULL_TREE;
12552
12553   if (! integer_all_onesp (size))
12554     {
12555       if (! host_integerp (len, 1))
12556         {
12557           /* If LEN is not constant, try MAXLEN too.
12558              For MAXLEN only allow optimizing into non-_ocs function
12559              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12560           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12561             return NULL_TREE;
12562         }
12563       else
12564         maxlen = len;
12565
12566       if (tree_int_cst_lt (size, maxlen))
12567         return NULL_TREE;
12568     }
12569
12570   /* If __builtin_strncpy_chk is used, assume strncpy is available.  */
12571   fn = built_in_decls[BUILT_IN_STRNCPY];
12572   if (!fn)
12573     return NULL_TREE;
12574
12575   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12576 }
12577
12578 /* Fold a call to the __strcat_chk builtin FNDECL.  DEST, SRC, and SIZE
12579    are the arguments to the call.  */
12580
12581 static tree
12582 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12583                          tree src, tree size)
12584 {
12585   tree fn;
12586   const char *p;
12587
12588   if (!validate_arg (dest, POINTER_TYPE)
12589       || !validate_arg (src, POINTER_TYPE)
12590       || !validate_arg (size, INTEGER_TYPE))
12591     return NULL_TREE;
12592
12593   p = c_getstr (src);
12594   /* If the SRC parameter is "", return DEST.  */
12595   if (p && *p == '\0')
12596     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12597
12598   if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12599     return NULL_TREE;
12600
12601   /* If __builtin_strcat_chk is used, assume strcat is available.  */
12602   fn = built_in_decls[BUILT_IN_STRCAT];
12603   if (!fn)
12604     return NULL_TREE;
12605
12606   return build_call_expr_loc (loc, fn, 2, dest, src);
12607 }
12608
12609 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12610    LEN, and SIZE.  */
12611
12612 static tree
12613 fold_builtin_strncat_chk (location_t loc, tree fndecl,
12614                           tree dest, tree src, tree len, tree size)
12615 {
12616   tree fn;
12617   const char *p;
12618
12619   if (!validate_arg (dest, POINTER_TYPE)
12620       || !validate_arg (src, POINTER_TYPE)
12621       || !validate_arg (size, INTEGER_TYPE)
12622       || !validate_arg (size, INTEGER_TYPE))
12623     return NULL_TREE;
12624
12625   p = c_getstr (src);
12626   /* If the SRC parameter is "" or if LEN is 0, return DEST.  */
12627   if (p && *p == '\0')
12628     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12629   else if (integer_zerop (len))
12630     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12631
12632   if (! host_integerp (size, 1))
12633     return NULL_TREE;
12634
12635   if (! integer_all_onesp (size))
12636     {
12637       tree src_len = c_strlen (src, 1);
12638       if (src_len
12639           && host_integerp (src_len, 1)
12640           && host_integerp (len, 1)
12641           && ! tree_int_cst_lt (len, src_len))
12642         {
12643           /* If LEN >= strlen (SRC), optimize into __strcat_chk.  */
12644           fn = built_in_decls[BUILT_IN_STRCAT_CHK];
12645           if (!fn)
12646             return NULL_TREE;
12647
12648           return build_call_expr_loc (loc, fn, 3, dest, src, size);
12649         }
12650       return NULL_TREE;
12651     }
12652
12653   /* If __builtin_strncat_chk is used, assume strncat is available.  */
12654   fn = built_in_decls[BUILT_IN_STRNCAT];
12655   if (!fn)
12656     return NULL_TREE;
12657
12658   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12659 }
12660
12661 /* Fold a call EXP to __{,v}sprintf_chk having NARGS passed as ARGS.
12662    Return NULL_TREE if a normal call should be emitted rather than
12663    expanding the function inline.  FCODE is either BUILT_IN_SPRINTF_CHK
12664    or BUILT_IN_VSPRINTF_CHK.  */
12665
12666 static tree
12667 fold_builtin_sprintf_chk_1 (location_t loc, int nargs, tree *args,
12668                             enum built_in_function fcode)
12669 {
12670   tree dest, size, len, fn, fmt, flag;
12671   const char *fmt_str;
12672
12673   /* Verify the required arguments in the original call.  */
12674   if (nargs < 4)
12675     return NULL_TREE;
12676   dest = args[0];
12677   if (!validate_arg (dest, POINTER_TYPE))
12678     return NULL_TREE;
12679   flag = args[1];
12680   if (!validate_arg (flag, INTEGER_TYPE))
12681     return NULL_TREE;
12682   size = args[2];
12683   if (!validate_arg (size, INTEGER_TYPE))
12684     return NULL_TREE;
12685   fmt = args[3];
12686   if (!validate_arg (fmt, POINTER_TYPE))
12687     return NULL_TREE;
12688
12689   if (! host_integerp (size, 1))
12690     return NULL_TREE;
12691
12692   len = NULL_TREE;
12693
12694   if (!init_target_chars ())
12695     return NULL_TREE;
12696
12697   /* Check whether the format is a literal string constant.  */
12698   fmt_str = c_getstr (fmt);
12699   if (fmt_str != NULL)
12700     {
12701       /* If the format doesn't contain % args or %%, we know the size.  */
12702       if (strchr (fmt_str, target_percent) == 0)
12703         {
12704           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
12705             len = build_int_cstu (size_type_node, strlen (fmt_str));
12706         }
12707       /* If the format is "%s" and first ... argument is a string literal,
12708          we know the size too.  */
12709       else if (fcode == BUILT_IN_SPRINTF_CHK
12710                && strcmp (fmt_str, target_percent_s) == 0)
12711         {
12712           tree arg;
12713
12714           if (nargs == 5)
12715             {
12716               arg = args[4];
12717               if (validate_arg (arg, POINTER_TYPE))
12718                 {
12719                   len = c_strlen (arg, 1);
12720                   if (! len || ! host_integerp (len, 1))
12721                     len = NULL_TREE;
12722                 }
12723             }
12724         }
12725     }
12726
12727   if (! integer_all_onesp (size))
12728     {
12729       if (! len || ! tree_int_cst_lt (len, size))
12730         return NULL_TREE;
12731     }
12732
12733   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12734      or if format doesn't contain % chars or is "%s".  */
12735   if (! integer_zerop (flag))
12736     {
12737       if (fmt_str == NULL)
12738         return NULL_TREE;
12739       if (strchr (fmt_str, target_percent) != NULL
12740           && strcmp (fmt_str, target_percent_s))
12741         return NULL_TREE;
12742     }
12743
12744   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
12745   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
12746                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
12747   if (!fn)
12748     return NULL_TREE;
12749
12750   return rewrite_call_expr_array (loc, nargs, args, 4, fn, 2, dest, fmt);
12751 }
12752
12753 /* Fold a call EXP to __{,v}sprintf_chk.  Return NULL_TREE if
12754    a normal call should be emitted rather than expanding the function
12755    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
12756
12757 static tree
12758 fold_builtin_sprintf_chk (location_t loc, tree exp,
12759                           enum built_in_function fcode)
12760 {
12761   return fold_builtin_sprintf_chk_1 (loc, call_expr_nargs (exp),
12762                                      CALL_EXPR_ARGP (exp), fcode);
12763 }
12764
12765 /* Fold a call EXP to {,v}snprintf having NARGS passed as ARGS.  Return
12766    NULL_TREE if a normal call should be emitted rather than expanding
12767    the function inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
12768    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
12769    passed as second argument.  */
12770
12771 static tree
12772 fold_builtin_snprintf_chk_1 (location_t loc, int nargs, tree *args,
12773                              tree maxlen, enum built_in_function fcode)
12774 {
12775   tree dest, size, len, fn, fmt, flag;
12776   const char *fmt_str;
12777
12778   /* Verify the required arguments in the original call.  */
12779   if (nargs < 5)
12780     return NULL_TREE;
12781   dest = args[0];
12782   if (!validate_arg (dest, POINTER_TYPE))
12783     return NULL_TREE;
12784   len = args[1];
12785   if (!validate_arg (len, INTEGER_TYPE))
12786     return NULL_TREE;
12787   flag = args[2];
12788   if (!validate_arg (flag, INTEGER_TYPE))
12789     return NULL_TREE;
12790   size = args[3];
12791   if (!validate_arg (size, INTEGER_TYPE))
12792     return NULL_TREE;
12793   fmt = args[4];
12794   if (!validate_arg (fmt, POINTER_TYPE))
12795     return NULL_TREE;
12796
12797   if (! host_integerp (size, 1))
12798     return NULL_TREE;
12799
12800   if (! integer_all_onesp (size))
12801     {
12802       if (! host_integerp (len, 1))
12803         {
12804           /* If LEN is not constant, try MAXLEN too.
12805              For MAXLEN only allow optimizing into non-_ocs function
12806              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12807           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12808             return NULL_TREE;
12809         }
12810       else
12811         maxlen = len;
12812
12813       if (tree_int_cst_lt (size, maxlen))
12814         return NULL_TREE;
12815     }
12816
12817   if (!init_target_chars ())
12818     return NULL_TREE;
12819
12820   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12821      or if format doesn't contain % chars or is "%s".  */
12822   if (! integer_zerop (flag))
12823     {
12824       fmt_str = c_getstr (fmt);
12825       if (fmt_str == NULL)
12826         return NULL_TREE;
12827       if (strchr (fmt_str, target_percent) != NULL
12828           && strcmp (fmt_str, target_percent_s))
12829         return NULL_TREE;
12830     }
12831
12832   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12833      available.  */
12834   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
12835                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
12836   if (!fn)
12837     return NULL_TREE;
12838
12839   return rewrite_call_expr_array (loc, nargs, args, 5, fn, 3, dest, len, fmt);
12840 }
12841
12842 /* Fold a call EXP to {,v}snprintf.  Return NULL_TREE if
12843    a normal call should be emitted rather than expanding the function
12844    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
12845    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
12846    passed as second argument.  */
12847
12848 tree
12849 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
12850                            enum built_in_function fcode)
12851 {
12852   return fold_builtin_snprintf_chk_1 (loc, call_expr_nargs (exp),
12853                                       CALL_EXPR_ARGP (exp), maxlen, fcode);
12854 }
12855
12856 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12857    FMT and ARG are the arguments to the call; we don't fold cases with
12858    more than 2 arguments, and ARG may be null if this is a 1-argument case.
12859
12860    Return NULL_TREE if no simplification was possible, otherwise return the
12861    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12862    code of the function to be simplified.  */
12863
12864 static tree
12865 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
12866                      tree arg, bool ignore,
12867                      enum built_in_function fcode)
12868 {
12869   tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
12870   const char *fmt_str = NULL;
12871
12872   /* If the return value is used, don't do the transformation.  */
12873   if (! ignore)
12874     return NULL_TREE;
12875
12876   /* Verify the required arguments in the original call.  */
12877   if (!validate_arg (fmt, POINTER_TYPE))
12878     return NULL_TREE;
12879
12880   /* Check whether the format is a literal string constant.  */
12881   fmt_str = c_getstr (fmt);
12882   if (fmt_str == NULL)
12883     return NULL_TREE;
12884
12885   if (fcode == BUILT_IN_PRINTF_UNLOCKED)
12886     {
12887       /* If we're using an unlocked function, assume the other
12888          unlocked functions exist explicitly.  */
12889       fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
12890       fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
12891     }
12892   else
12893     {
12894       fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
12895       fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
12896     }
12897
12898   if (!init_target_chars ())
12899     return NULL_TREE;
12900
12901   if (strcmp (fmt_str, target_percent_s) == 0
12902       || strchr (fmt_str, target_percent) == NULL)
12903     {
12904       const char *str;
12905
12906       if (strcmp (fmt_str, target_percent_s) == 0)
12907         {
12908           if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12909             return NULL_TREE;
12910
12911           if (!arg || !validate_arg (arg, POINTER_TYPE))
12912             return NULL_TREE;
12913
12914           str = c_getstr (arg);
12915           if (str == NULL)
12916             return NULL_TREE;
12917         }
12918       else
12919         {
12920           /* The format specifier doesn't contain any '%' characters.  */
12921           if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
12922               && arg)
12923             return NULL_TREE;
12924           str = fmt_str;
12925         }
12926
12927       /* If the string was "", printf does nothing.  */
12928       if (str[0] == '\0')
12929         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12930
12931       /* If the string has length of 1, call putchar.  */
12932       if (str[1] == '\0')
12933         {
12934           /* Given printf("c"), (where c is any one character,)
12935              convert "c"[0] to an int and pass that to the replacement
12936              function.  */
12937           newarg = build_int_cst (NULL_TREE, str[0]);
12938           if (fn_putchar)
12939             call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
12940         }
12941       else
12942         {
12943           /* If the string was "string\n", call puts("string").  */
12944           size_t len = strlen (str);
12945           if ((unsigned char)str[len - 1] == target_newline
12946               && (size_t) (int) len == len
12947               && (int) len > 0)
12948             {
12949               char *newstr;
12950               tree offset_node, string_cst;
12951
12952               /* Create a NUL-terminated string that's one char shorter
12953                  than the original, stripping off the trailing '\n'.  */
12954               newarg = build_string_literal (len, str);
12955               string_cst = string_constant (newarg, &offset_node);
12956               gcc_checking_assert (string_cst
12957                                    && (TREE_STRING_LENGTH (string_cst)
12958                                        == (int) len)
12959                                    && integer_zerop (offset_node)
12960                                    && (unsigned char)
12961                                       TREE_STRING_POINTER (string_cst)[len - 1]
12962                                       == target_newline);
12963               /* build_string_literal creates a new STRING_CST,
12964                  modify it in place to avoid double copying.  */
12965               newstr = CONST_CAST (char *, TREE_STRING_POINTER (string_cst));
12966               newstr[len - 1] = '\0';
12967               if (fn_puts)
12968                 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
12969             }
12970           else
12971             /* We'd like to arrange to call fputs(string,stdout) here,
12972                but we need stdout and don't have a way to get it yet.  */
12973             return NULL_TREE;
12974         }
12975     }
12976
12977   /* The other optimizations can be done only on the non-va_list variants.  */
12978   else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12979     return NULL_TREE;
12980
12981   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
12982   else if (strcmp (fmt_str, target_percent_s_newline) == 0)
12983     {
12984       if (!arg || !validate_arg (arg, POINTER_TYPE))
12985         return NULL_TREE;
12986       if (fn_puts)
12987         call = build_call_expr_loc (loc, fn_puts, 1, arg);
12988     }
12989
12990   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
12991   else if (strcmp (fmt_str, target_percent_c) == 0)
12992     {
12993       if (!arg || !validate_arg (arg, INTEGER_TYPE))
12994         return NULL_TREE;
12995       if (fn_putchar)
12996         call = build_call_expr_loc (loc, fn_putchar, 1, arg);
12997     }
12998
12999   if (!call)
13000     return NULL_TREE;
13001
13002   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
13003 }
13004
13005 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
13006    FP, FMT, and ARG are the arguments to the call.  We don't fold calls with
13007    more than 3 arguments, and ARG may be null in the 2-argument case.
13008
13009    Return NULL_TREE if no simplification was possible, otherwise return the
13010    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
13011    code of the function to be simplified.  */
13012
13013 static tree
13014 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
13015                       tree fmt, tree arg, bool ignore,
13016                       enum built_in_function fcode)
13017 {
13018   tree fn_fputc, fn_fputs, call = NULL_TREE;
13019   const char *fmt_str = NULL;
13020
13021   /* If the return value is used, don't do the transformation.  */
13022   if (! ignore)
13023     return NULL_TREE;
13024
13025   /* Verify the required arguments in the original call.  */
13026   if (!validate_arg (fp, POINTER_TYPE))
13027     return NULL_TREE;
13028   if (!validate_arg (fmt, POINTER_TYPE))
13029     return NULL_TREE;
13030
13031   /* Check whether the format is a literal string constant.  */
13032   fmt_str = c_getstr (fmt);
13033   if (fmt_str == NULL)
13034     return NULL_TREE;
13035
13036   if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
13037     {
13038       /* If we're using an unlocked function, assume the other
13039          unlocked functions exist explicitly.  */
13040       fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
13041       fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
13042     }
13043   else
13044     {
13045       fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
13046       fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
13047     }
13048
13049   if (!init_target_chars ())
13050     return NULL_TREE;
13051
13052   /* If the format doesn't contain % args or %%, use strcpy.  */
13053   if (strchr (fmt_str, target_percent) == NULL)
13054     {
13055       if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
13056           && arg)
13057         return NULL_TREE;
13058
13059       /* If the format specifier was "", fprintf does nothing.  */
13060       if (fmt_str[0] == '\0')
13061         {
13062           /* If FP has side-effects, just wait until gimplification is
13063              done.  */
13064           if (TREE_SIDE_EFFECTS (fp))
13065             return NULL_TREE;
13066
13067           return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
13068         }
13069
13070       /* When "string" doesn't contain %, replace all cases of
13071          fprintf (fp, string) with fputs (string, fp).  The fputs
13072          builtin will take care of special cases like length == 1.  */
13073       if (fn_fputs)
13074         call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
13075     }
13076
13077   /* The other optimizations can be done only on the non-va_list variants.  */
13078   else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
13079     return NULL_TREE;
13080
13081   /* If the format specifier was "%s", call __builtin_fputs (arg, fp).  */
13082   else if (strcmp (fmt_str, target_percent_s) == 0)
13083     {
13084       if (!arg || !validate_arg (arg, POINTER_TYPE))
13085         return NULL_TREE;
13086       if (fn_fputs)
13087         call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
13088     }
13089
13090   /* If the format specifier was "%c", call __builtin_fputc (arg, fp).  */
13091   else if (strcmp (fmt_str, target_percent_c) == 0)
13092     {
13093       if (!arg || !validate_arg (arg, INTEGER_TYPE))
13094         return NULL_TREE;
13095       if (fn_fputc)
13096         call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
13097     }
13098
13099   if (!call)
13100     return NULL_TREE;
13101   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
13102 }
13103
13104 /* Initialize format string characters in the target charset.  */
13105
13106 static bool
13107 init_target_chars (void)
13108 {
13109   static bool init;
13110   if (!init)
13111     {
13112       target_newline = lang_hooks.to_target_charset ('\n');
13113       target_percent = lang_hooks.to_target_charset ('%');
13114       target_c = lang_hooks.to_target_charset ('c');
13115       target_s = lang_hooks.to_target_charset ('s');
13116       if (target_newline == 0 || target_percent == 0 || target_c == 0
13117           || target_s == 0)
13118         return false;
13119
13120       target_percent_c[0] = target_percent;
13121       target_percent_c[1] = target_c;
13122       target_percent_c[2] = '\0';
13123
13124       target_percent_s[0] = target_percent;
13125       target_percent_s[1] = target_s;
13126       target_percent_s[2] = '\0';
13127
13128       target_percent_s_newline[0] = target_percent;
13129       target_percent_s_newline[1] = target_s;
13130       target_percent_s_newline[2] = target_newline;
13131       target_percent_s_newline[3] = '\0';
13132
13133       init = true;
13134     }
13135   return true;
13136 }
13137
13138 /* Helper function for do_mpfr_arg*().  Ensure M is a normal number
13139    and no overflow/underflow occurred.  INEXACT is true if M was not
13140    exactly calculated.  TYPE is the tree type for the result.  This
13141    function assumes that you cleared the MPFR flags and then
13142    calculated M to see if anything subsequently set a flag prior to
13143    entering this function.  Return NULL_TREE if any checks fail.  */
13144
13145 static tree
13146 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
13147 {
13148   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13149      overflow/underflow occurred.  If -frounding-math, proceed iff the
13150      result of calling FUNC was exact.  */
13151   if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
13152       && (!flag_rounding_math || !inexact))
13153     {
13154       REAL_VALUE_TYPE rr;
13155
13156       real_from_mpfr (&rr, m, type, GMP_RNDN);
13157       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
13158          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
13159          but the mpft_t is not, then we underflowed in the
13160          conversion.  */
13161       if (real_isfinite (&rr)
13162           && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
13163         {
13164           REAL_VALUE_TYPE rmode;
13165
13166           real_convert (&rmode, TYPE_MODE (type), &rr);
13167           /* Proceed iff the specified mode can hold the value.  */
13168           if (real_identical (&rmode, &rr))
13169             return build_real (type, rmode);
13170         }
13171     }
13172   return NULL_TREE;
13173 }
13174
13175 /* Helper function for do_mpc_arg*().  Ensure M is a normal complex
13176    number and no overflow/underflow occurred.  INEXACT is true if M
13177    was not exactly calculated.  TYPE is the tree type for the result.
13178    This function assumes that you cleared the MPFR flags and then
13179    calculated M to see if anything subsequently set a flag prior to
13180    entering this function.  Return NULL_TREE if any checks fail, if
13181    FORCE_CONVERT is true, then bypass the checks.  */
13182
13183 static tree
13184 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
13185 {
13186   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13187      overflow/underflow occurred.  If -frounding-math, proceed iff the
13188      result of calling FUNC was exact.  */
13189   if (force_convert
13190       || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
13191           && !mpfr_overflow_p () && !mpfr_underflow_p ()
13192           && (!flag_rounding_math || !inexact)))
13193     {
13194       REAL_VALUE_TYPE re, im;
13195
13196       real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
13197       real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
13198       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
13199          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
13200          but the mpft_t is not, then we underflowed in the
13201          conversion.  */
13202       if (force_convert
13203           || (real_isfinite (&re) && real_isfinite (&im)
13204               && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
13205               && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
13206         {
13207           REAL_VALUE_TYPE re_mode, im_mode;
13208
13209           real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
13210           real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
13211           /* Proceed iff the specified mode can hold the value.  */
13212           if (force_convert
13213               || (real_identical (&re_mode, &re)
13214                   && real_identical (&im_mode, &im)))
13215             return build_complex (type, build_real (TREE_TYPE (type), re_mode),
13216                                   build_real (TREE_TYPE (type), im_mode));
13217         }
13218     }
13219   return NULL_TREE;
13220 }
13221
13222 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
13223    FUNC on it and return the resulting value as a tree with type TYPE.
13224    If MIN and/or MAX are not NULL, then the supplied ARG must be
13225    within those bounds.  If INCLUSIVE is true, then MIN/MAX are
13226    acceptable values, otherwise they are not.  The mpfr precision is
13227    set to the precision of TYPE.  We assume that function FUNC returns
13228    zero if the result could be calculated exactly within the requested
13229    precision.  */
13230
13231 static tree
13232 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
13233               const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
13234               bool inclusive)
13235 {
13236   tree result = NULL_TREE;
13237
13238   STRIP_NOPS (arg);
13239
13240   /* To proceed, MPFR must exactly represent the target floating point
13241      format, which only happens when the target base equals two.  */
13242   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13243       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13244     {
13245       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13246
13247       if (real_isfinite (ra)
13248           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13249           && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13250         {
13251           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13252           const int prec = fmt->p;
13253           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13254           int inexact;
13255           mpfr_t m;
13256
13257           mpfr_init2 (m, prec);
13258           mpfr_from_real (m, ra, GMP_RNDN);
13259           mpfr_clear_flags ();
13260           inexact = func (m, m, rnd);
13261           result = do_mpfr_ckconv (m, type, inexact);
13262           mpfr_clear (m);
13263         }
13264     }
13265
13266   return result;
13267 }
13268
13269 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13270    FUNC on it and return the resulting value as a tree with type TYPE.
13271    The mpfr precision is set to the precision of TYPE.  We assume that
13272    function FUNC returns zero if the result could be calculated
13273    exactly within the requested precision.  */
13274
13275 static tree
13276 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13277               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13278 {
13279   tree result = NULL_TREE;
13280
13281   STRIP_NOPS (arg1);
13282   STRIP_NOPS (arg2);
13283
13284   /* To proceed, MPFR must exactly represent the target floating point
13285      format, which only happens when the target base equals two.  */
13286   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13287       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13288       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13289     {
13290       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13291       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13292
13293       if (real_isfinite (ra1) && real_isfinite (ra2))
13294         {
13295           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13296           const int prec = fmt->p;
13297           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13298           int inexact;
13299           mpfr_t m1, m2;
13300
13301           mpfr_inits2 (prec, m1, m2, NULL);
13302           mpfr_from_real (m1, ra1, GMP_RNDN);
13303           mpfr_from_real (m2, ra2, GMP_RNDN);
13304           mpfr_clear_flags ();
13305           inexact = func (m1, m1, m2, rnd);
13306           result = do_mpfr_ckconv (m1, type, inexact);
13307           mpfr_clears (m1, m2, NULL);
13308         }
13309     }
13310
13311   return result;
13312 }
13313
13314 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13315    FUNC on it and return the resulting value as a tree with type TYPE.
13316    The mpfr precision is set to the precision of TYPE.  We assume that
13317    function FUNC returns zero if the result could be calculated
13318    exactly within the requested precision.  */
13319
13320 static tree
13321 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13322               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13323 {
13324   tree result = NULL_TREE;
13325
13326   STRIP_NOPS (arg1);
13327   STRIP_NOPS (arg2);
13328   STRIP_NOPS (arg3);
13329
13330   /* To proceed, MPFR must exactly represent the target floating point
13331      format, which only happens when the target base equals two.  */
13332   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13333       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13334       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13335       && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13336     {
13337       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13338       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13339       const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13340
13341       if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13342         {
13343           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13344           const int prec = fmt->p;
13345           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13346           int inexact;
13347           mpfr_t m1, m2, m3;
13348
13349           mpfr_inits2 (prec, m1, m2, m3, NULL);
13350           mpfr_from_real (m1, ra1, GMP_RNDN);
13351           mpfr_from_real (m2, ra2, GMP_RNDN);
13352           mpfr_from_real (m3, ra3, GMP_RNDN);
13353           mpfr_clear_flags ();
13354           inexact = func (m1, m1, m2, m3, rnd);
13355           result = do_mpfr_ckconv (m1, type, inexact);
13356           mpfr_clears (m1, m2, m3, NULL);
13357         }
13358     }
13359
13360   return result;
13361 }
13362
13363 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13364    the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13365    If ARG_SINP and ARG_COSP are NULL then the result is returned
13366    as a complex value.
13367    The type is taken from the type of ARG and is used for setting the
13368    precision of the calculation and results.  */
13369
13370 static tree
13371 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13372 {
13373   tree const type = TREE_TYPE (arg);
13374   tree result = NULL_TREE;
13375
13376   STRIP_NOPS (arg);
13377
13378   /* To proceed, MPFR must exactly represent the target floating point
13379      format, which only happens when the target base equals two.  */
13380   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13381       && TREE_CODE (arg) == REAL_CST
13382       && !TREE_OVERFLOW (arg))
13383     {
13384       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13385
13386       if (real_isfinite (ra))
13387         {
13388           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13389           const int prec = fmt->p;
13390           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13391           tree result_s, result_c;
13392           int inexact;
13393           mpfr_t m, ms, mc;
13394
13395           mpfr_inits2 (prec, m, ms, mc, NULL);
13396           mpfr_from_real (m, ra, GMP_RNDN);
13397           mpfr_clear_flags ();
13398           inexact = mpfr_sin_cos (ms, mc, m, rnd);
13399           result_s = do_mpfr_ckconv (ms, type, inexact);
13400           result_c = do_mpfr_ckconv (mc, type, inexact);
13401           mpfr_clears (m, ms, mc, NULL);
13402           if (result_s && result_c)
13403             {
13404               /* If we are to return in a complex value do so.  */
13405               if (!arg_sinp && !arg_cosp)
13406                 return build_complex (build_complex_type (type),
13407                                       result_c, result_s);
13408
13409               /* Dereference the sin/cos pointer arguments.  */
13410               arg_sinp = build_fold_indirect_ref (arg_sinp);
13411               arg_cosp = build_fold_indirect_ref (arg_cosp);
13412               /* Proceed if valid pointer type were passed in.  */
13413               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13414                   && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13415                 {
13416                   /* Set the values. */
13417                   result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13418                                           result_s);
13419                   TREE_SIDE_EFFECTS (result_s) = 1;
13420                   result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13421                                           result_c);
13422                   TREE_SIDE_EFFECTS (result_c) = 1;
13423                   /* Combine the assignments into a compound expr.  */
13424                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13425                                                     result_s, result_c));
13426                 }
13427             }
13428         }
13429     }
13430   return result;
13431 }
13432
13433 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13434    two-argument mpfr order N Bessel function FUNC on them and return
13435    the resulting value as a tree with type TYPE.  The mpfr precision
13436    is set to the precision of TYPE.  We assume that function FUNC
13437    returns zero if the result could be calculated exactly within the
13438    requested precision.  */
13439 static tree
13440 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13441                   int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13442                   const REAL_VALUE_TYPE *min, bool inclusive)
13443 {
13444   tree result = NULL_TREE;
13445
13446   STRIP_NOPS (arg1);
13447   STRIP_NOPS (arg2);
13448
13449   /* To proceed, MPFR must exactly represent the target floating point
13450      format, which only happens when the target base equals two.  */
13451   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13452       && host_integerp (arg1, 0)
13453       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13454     {
13455       const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13456       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13457
13458       if (n == (long)n
13459           && real_isfinite (ra)
13460           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13461         {
13462           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13463           const int prec = fmt->p;
13464           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13465           int inexact;
13466           mpfr_t m;
13467
13468           mpfr_init2 (m, prec);
13469           mpfr_from_real (m, ra, GMP_RNDN);
13470           mpfr_clear_flags ();
13471           inexact = func (m, n, m, rnd);
13472           result = do_mpfr_ckconv (m, type, inexact);
13473           mpfr_clear (m);
13474         }
13475     }
13476
13477   return result;
13478 }
13479
13480 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13481    the pointer *(ARG_QUO) and return the result.  The type is taken
13482    from the type of ARG0 and is used for setting the precision of the
13483    calculation and results.  */
13484
13485 static tree
13486 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13487 {
13488   tree const type = TREE_TYPE (arg0);
13489   tree result = NULL_TREE;
13490
13491   STRIP_NOPS (arg0);
13492   STRIP_NOPS (arg1);
13493
13494   /* To proceed, MPFR must exactly represent the target floating point
13495      format, which only happens when the target base equals two.  */
13496   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13497       && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13498       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13499     {
13500       const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13501       const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13502
13503       if (real_isfinite (ra0) && real_isfinite (ra1))
13504         {
13505           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13506           const int prec = fmt->p;
13507           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13508           tree result_rem;
13509           long integer_quo;
13510           mpfr_t m0, m1;
13511
13512           mpfr_inits2 (prec, m0, m1, NULL);
13513           mpfr_from_real (m0, ra0, GMP_RNDN);
13514           mpfr_from_real (m1, ra1, GMP_RNDN);
13515           mpfr_clear_flags ();
13516           mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13517           /* Remquo is independent of the rounding mode, so pass
13518              inexact=0 to do_mpfr_ckconv().  */
13519           result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13520           mpfr_clears (m0, m1, NULL);
13521           if (result_rem)
13522             {
13523               /* MPFR calculates quo in the host's long so it may
13524                  return more bits in quo than the target int can hold
13525                  if sizeof(host long) > sizeof(target int).  This can
13526                  happen even for native compilers in LP64 mode.  In
13527                  these cases, modulo the quo value with the largest
13528                  number that the target int can hold while leaving one
13529                  bit for the sign.  */
13530               if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13531                 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13532
13533               /* Dereference the quo pointer argument.  */
13534               arg_quo = build_fold_indirect_ref (arg_quo);
13535               /* Proceed iff a valid pointer type was passed in.  */
13536               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13537                 {
13538                   /* Set the value. */
13539                   tree result_quo = fold_build2 (MODIFY_EXPR,
13540                                                  TREE_TYPE (arg_quo), arg_quo,
13541                                                  build_int_cst (NULL, integer_quo));
13542                   TREE_SIDE_EFFECTS (result_quo) = 1;
13543                   /* Combine the quo assignment with the rem.  */
13544                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13545                                                     result_quo, result_rem));
13546                 }
13547             }
13548         }
13549     }
13550   return result;
13551 }
13552
13553 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13554    resulting value as a tree with type TYPE.  The mpfr precision is
13555    set to the precision of TYPE.  We assume that this mpfr function
13556    returns zero if the result could be calculated exactly within the
13557    requested precision.  In addition, the integer pointer represented
13558    by ARG_SG will be dereferenced and set to the appropriate signgam
13559    (-1,1) value.  */
13560
13561 static tree
13562 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13563 {
13564   tree result = NULL_TREE;
13565
13566   STRIP_NOPS (arg);
13567
13568   /* To proceed, MPFR must exactly represent the target floating point
13569      format, which only happens when the target base equals two.  Also
13570      verify ARG is a constant and that ARG_SG is an int pointer.  */
13571   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13572       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13573       && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13574       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13575     {
13576       const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13577
13578       /* In addition to NaN and Inf, the argument cannot be zero or a
13579          negative integer.  */
13580       if (real_isfinite (ra)
13581           && ra->cl != rvc_zero
13582           && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13583         {
13584           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13585           const int prec = fmt->p;
13586           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13587           int inexact, sg;
13588           mpfr_t m;
13589           tree result_lg;
13590
13591           mpfr_init2 (m, prec);
13592           mpfr_from_real (m, ra, GMP_RNDN);
13593           mpfr_clear_flags ();
13594           inexact = mpfr_lgamma (m, &sg, m, rnd);
13595           result_lg = do_mpfr_ckconv (m, type, inexact);
13596           mpfr_clear (m);
13597           if (result_lg)
13598             {
13599               tree result_sg;
13600
13601               /* Dereference the arg_sg pointer argument.  */
13602               arg_sg = build_fold_indirect_ref (arg_sg);
13603               /* Assign the signgam value into *arg_sg. */
13604               result_sg = fold_build2 (MODIFY_EXPR,
13605                                        TREE_TYPE (arg_sg), arg_sg,
13606                                        build_int_cst (NULL, sg));
13607               TREE_SIDE_EFFECTS (result_sg) = 1;
13608               /* Combine the signgam assignment with the lgamma result.  */
13609               result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13610                                                 result_sg, result_lg));
13611             }
13612         }
13613     }
13614
13615   return result;
13616 }
13617
13618 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13619    function FUNC on it and return the resulting value as a tree with
13620    type TYPE.  The mpfr precision is set to the precision of TYPE.  We
13621    assume that function FUNC returns zero if the result could be
13622    calculated exactly within the requested precision.  */
13623
13624 static tree
13625 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13626 {
13627   tree result = NULL_TREE;
13628
13629   STRIP_NOPS (arg);
13630
13631   /* To proceed, MPFR must exactly represent the target floating point
13632      format, which only happens when the target base equals two.  */
13633   if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
13634       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
13635       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
13636     {
13637       const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
13638       const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
13639
13640       if (real_isfinite (re) && real_isfinite (im))
13641         {
13642           const struct real_format *const fmt =
13643             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13644           const int prec = fmt->p;
13645           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13646           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13647           int inexact;
13648           mpc_t m;
13649
13650           mpc_init2 (m, prec);
13651           mpfr_from_real (mpc_realref(m), re, rnd);
13652           mpfr_from_real (mpc_imagref(m), im, rnd);
13653           mpfr_clear_flags ();
13654           inexact = func (m, m, crnd);
13655           result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
13656           mpc_clear (m);
13657         }
13658     }
13659
13660   return result;
13661 }
13662
13663 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
13664    mpc function FUNC on it and return the resulting value as a tree
13665    with type TYPE.  The mpfr precision is set to the precision of
13666    TYPE.  We assume that function FUNC returns zero if the result
13667    could be calculated exactly within the requested precision.  If
13668    DO_NONFINITE is true, then fold expressions containing Inf or NaN
13669    in the arguments and/or results.  */
13670
13671 tree
13672 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
13673              int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
13674 {
13675   tree result = NULL_TREE;
13676
13677   STRIP_NOPS (arg0);
13678   STRIP_NOPS (arg1);
13679
13680   /* To proceed, MPFR must exactly represent the target floating point
13681      format, which only happens when the target base equals two.  */
13682   if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
13683       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
13684       && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
13685       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
13686       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
13687     {
13688       const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
13689       const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
13690       const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
13691       const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
13692
13693       if (do_nonfinite
13694           || (real_isfinite (re0) && real_isfinite (im0)
13695               && real_isfinite (re1) && real_isfinite (im1)))
13696         {
13697           const struct real_format *const fmt =
13698             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13699           const int prec = fmt->p;
13700           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13701           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13702           int inexact;
13703           mpc_t m0, m1;
13704
13705           mpc_init2 (m0, prec);
13706           mpc_init2 (m1, prec);
13707           mpfr_from_real (mpc_realref(m0), re0, rnd);
13708           mpfr_from_real (mpc_imagref(m0), im0, rnd);
13709           mpfr_from_real (mpc_realref(m1), re1, rnd);
13710           mpfr_from_real (mpc_imagref(m1), im1, rnd);
13711           mpfr_clear_flags ();
13712           inexact = func (m0, m0, m1, crnd);
13713           result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
13714           mpc_clear (m0);
13715           mpc_clear (m1);
13716         }
13717     }
13718
13719   return result;
13720 }
13721
13722 /* Fold a call STMT to __{,v}sprintf_chk.  Return NULL_TREE if
13723    a normal call should be emitted rather than expanding the function
13724    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
13725
13726 static tree
13727 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
13728 {
13729   int nargs = gimple_call_num_args (stmt);
13730
13731   return fold_builtin_sprintf_chk_1 (gimple_location (stmt), nargs,
13732                                      (nargs > 0
13733                                       ? gimple_call_arg_ptr (stmt, 0)
13734                                       : &error_mark_node), fcode);
13735 }
13736
13737 /* Fold a call STMT to {,v}snprintf.  Return NULL_TREE if
13738    a normal call should be emitted rather than expanding the function
13739    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
13740    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
13741    passed as second argument.  */
13742
13743 tree
13744 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
13745                                   enum built_in_function fcode)
13746 {
13747   int nargs = gimple_call_num_args (stmt);
13748
13749   return fold_builtin_snprintf_chk_1 (gimple_location (stmt), nargs,
13750                                       (nargs > 0
13751                                        ? gimple_call_arg_ptr (stmt, 0)
13752                                        : &error_mark_node), maxlen, fcode);
13753 }
13754
13755 /* Builtins with folding operations that operate on "..." arguments
13756    need special handling; we need to store the arguments in a convenient
13757    data structure before attempting any folding.  Fortunately there are
13758    only a few builtins that fall into this category.  FNDECL is the
13759    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13760    result of the function call is ignored.  */
13761
13762 static tree
13763 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
13764                              bool ignore ATTRIBUTE_UNUSED)
13765 {
13766   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13767   tree ret = NULL_TREE;
13768
13769   switch (fcode)
13770     {
13771     case BUILT_IN_SPRINTF_CHK:
13772     case BUILT_IN_VSPRINTF_CHK:
13773       ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
13774       break;
13775
13776     case BUILT_IN_SNPRINTF_CHK:
13777     case BUILT_IN_VSNPRINTF_CHK:
13778       ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
13779
13780     default:
13781       break;
13782     }
13783   if (ret)
13784     {
13785       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
13786       TREE_NO_WARNING (ret) = 1;
13787       return ret;
13788     }
13789   return NULL_TREE;
13790 }
13791
13792 /* A wrapper function for builtin folding that prevents warnings for
13793    "statement without effect" and the like, caused by removing the
13794    call node earlier than the warning is generated.  */
13795
13796 tree
13797 fold_call_stmt (gimple stmt, bool ignore)
13798 {
13799   tree ret = NULL_TREE;
13800   tree fndecl = gimple_call_fndecl (stmt);
13801   location_t loc = gimple_location (stmt);
13802   if (fndecl
13803       && TREE_CODE (fndecl) == FUNCTION_DECL
13804       && DECL_BUILT_IN (fndecl)
13805       && !gimple_call_va_arg_pack_p (stmt))
13806     {
13807       int nargs = gimple_call_num_args (stmt);
13808       tree *args = (nargs > 0
13809                     ? gimple_call_arg_ptr (stmt, 0)
13810                     : &error_mark_node);
13811
13812       if (avoid_folding_inline_builtin (fndecl))
13813         return NULL_TREE;
13814       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
13815         {
13816           return targetm.fold_builtin (fndecl, nargs, args, ignore);
13817         }
13818       else
13819         {
13820           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
13821             ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
13822           if (!ret)
13823             ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
13824           if (ret)
13825             {
13826               /* Propagate location information from original call to
13827                  expansion of builtin.  Otherwise things like
13828                  maybe_emit_chk_warning, that operate on the expansion
13829                  of a builtin, will use the wrong location information.  */
13830               if (gimple_has_location (stmt))
13831                 {
13832                   tree realret = ret;
13833                   if (TREE_CODE (ret) == NOP_EXPR)
13834                     realret = TREE_OPERAND (ret, 0);
13835                   if (CAN_HAVE_LOCATION_P (realret)
13836                       && !EXPR_HAS_LOCATION (realret))
13837                     SET_EXPR_LOCATION (realret, loc);
13838                   return realret;
13839                 }
13840               return ret;
13841             }
13842         }
13843     }
13844   return NULL_TREE;
13845 }
13846
13847 /* Look up the function in built_in_decls that corresponds to DECL
13848    and set ASMSPEC as its user assembler name.  DECL must be a
13849    function decl that declares a builtin.  */
13850
13851 void
13852 set_builtin_user_assembler_name (tree decl, const char *asmspec)
13853 {
13854   tree builtin;
13855   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
13856               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
13857               && asmspec != 0);
13858
13859   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
13860   set_user_assembler_name (builtin, asmspec);
13861   switch (DECL_FUNCTION_CODE (decl))
13862     {
13863     case BUILT_IN_MEMCPY:
13864       init_block_move_fn (asmspec);
13865       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
13866       break;
13867     case BUILT_IN_MEMSET:
13868       init_block_clear_fn (asmspec);
13869       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
13870       break;
13871     case BUILT_IN_MEMMOVE:
13872       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
13873       break;
13874     case BUILT_IN_MEMCMP:
13875       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
13876       break;
13877     case BUILT_IN_ABORT:
13878       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
13879       break;
13880     case BUILT_IN_FFS:
13881       if (INT_TYPE_SIZE < BITS_PER_WORD)
13882         {
13883           set_user_assembler_libfunc ("ffs", asmspec);
13884           set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
13885                                                        MODE_INT, 0), "ffs");
13886         }
13887       break;
13888     default:
13889       break;
13890     }
13891 }
13892
13893 /* Return true if DECL is a builtin that expands to a constant or similarly
13894    simple code.  */
13895 bool
13896 is_simple_builtin (tree decl)
13897 {
13898   if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13899     switch (DECL_FUNCTION_CODE (decl))
13900       {
13901         /* Builtins that expand to constants.  */
13902       case BUILT_IN_CONSTANT_P:
13903       case BUILT_IN_EXPECT:
13904       case BUILT_IN_OBJECT_SIZE:
13905       case BUILT_IN_UNREACHABLE:
13906         /* Simple register moves or loads from stack.  */
13907       case BUILT_IN_RETURN_ADDRESS:
13908       case BUILT_IN_EXTRACT_RETURN_ADDR:
13909       case BUILT_IN_FROB_RETURN_ADDR:
13910       case BUILT_IN_RETURN:
13911       case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
13912       case BUILT_IN_FRAME_ADDRESS:
13913       case BUILT_IN_VA_END:
13914       case BUILT_IN_STACK_SAVE:
13915       case BUILT_IN_STACK_RESTORE:
13916         /* Exception state returns or moves registers around.  */
13917       case BUILT_IN_EH_FILTER:
13918       case BUILT_IN_EH_POINTER:
13919       case BUILT_IN_EH_COPY_VALUES:
13920         return true;
13921
13922       default:
13923         return false;
13924       }
13925
13926   return false;
13927 }
13928
13929 /* Return true if DECL is a builtin that is not expensive, i.e., they are
13930    most probably expanded inline into reasonably simple code.  This is a
13931    superset of is_simple_builtin.  */
13932 bool
13933 is_inexpensive_builtin (tree decl)
13934 {
13935   if (!decl)
13936     return false;
13937   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
13938     return true;
13939   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13940     switch (DECL_FUNCTION_CODE (decl))
13941       {
13942       case BUILT_IN_ABS:
13943       case BUILT_IN_ALLOCA:
13944       case BUILT_IN_BSWAP32:
13945       case BUILT_IN_BSWAP64:
13946       case BUILT_IN_CLZ:
13947       case BUILT_IN_CLZIMAX:
13948       case BUILT_IN_CLZL:
13949       case BUILT_IN_CLZLL:
13950       case BUILT_IN_CTZ:
13951       case BUILT_IN_CTZIMAX:
13952       case BUILT_IN_CTZL:
13953       case BUILT_IN_CTZLL:
13954       case BUILT_IN_FFS:
13955       case BUILT_IN_FFSIMAX:
13956       case BUILT_IN_FFSL:
13957       case BUILT_IN_FFSLL:
13958       case BUILT_IN_IMAXABS:
13959       case BUILT_IN_FINITE:
13960       case BUILT_IN_FINITEF:
13961       case BUILT_IN_FINITEL:
13962       case BUILT_IN_FINITED32:
13963       case BUILT_IN_FINITED64:
13964       case BUILT_IN_FINITED128:
13965       case BUILT_IN_FPCLASSIFY:
13966       case BUILT_IN_ISFINITE:
13967       case BUILT_IN_ISINF_SIGN:
13968       case BUILT_IN_ISINF:
13969       case BUILT_IN_ISINFF:
13970       case BUILT_IN_ISINFL:
13971       case BUILT_IN_ISINFD32:
13972       case BUILT_IN_ISINFD64:
13973       case BUILT_IN_ISINFD128:
13974       case BUILT_IN_ISNAN:
13975       case BUILT_IN_ISNANF:
13976       case BUILT_IN_ISNANL:
13977       case BUILT_IN_ISNAND32:
13978       case BUILT_IN_ISNAND64:
13979       case BUILT_IN_ISNAND128:
13980       case BUILT_IN_ISNORMAL:
13981       case BUILT_IN_ISGREATER:
13982       case BUILT_IN_ISGREATEREQUAL:
13983       case BUILT_IN_ISLESS:
13984       case BUILT_IN_ISLESSEQUAL:
13985       case BUILT_IN_ISLESSGREATER:
13986       case BUILT_IN_ISUNORDERED:
13987       case BUILT_IN_VA_ARG_PACK:
13988       case BUILT_IN_VA_ARG_PACK_LEN:
13989       case BUILT_IN_VA_COPY:
13990       case BUILT_IN_TRAP:
13991       case BUILT_IN_SAVEREGS:
13992       case BUILT_IN_POPCOUNTL:
13993       case BUILT_IN_POPCOUNTLL:
13994       case BUILT_IN_POPCOUNTIMAX:
13995       case BUILT_IN_POPCOUNT:
13996       case BUILT_IN_PARITYL:
13997       case BUILT_IN_PARITYLL:
13998       case BUILT_IN_PARITYIMAX:
13999       case BUILT_IN_PARITY:
14000       case BUILT_IN_LABS:
14001       case BUILT_IN_LLABS:
14002       case BUILT_IN_PREFETCH:
14003         return true;
14004
14005       default:
14006         return is_simple_builtin (decl);
14007       }
14008
14009   return false;
14010 }