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    2012 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 builtin_info_type builtin_info;
  79
  80 static const char *c_getstr (tree);
  81 static rtx c_readstr (const char *, enum machine_mode);
  82 static int target_char_cast (tree, char *);
  83 static rtx get_memory_rtx (tree, tree);
  84 static int apply_args_size (void);
  85 static int apply_result_size (void);
  86 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
  87 static rtx result_vector (int, rtx);
  88 #endif
  89 static void expand_builtin_update_setjmp_buf (rtx);
  90 static void expand_builtin_prefetch (tree);
  91 static rtx expand_builtin_apply_args (void);
  92 static rtx expand_builtin_apply_args_1 (void);
  93 static rtx expand_builtin_apply (rtx, rtx, rtx);
  94 static void expand_builtin_return (rtx);
  95 static enum type_class type_to_class (tree);
  96 static rtx expand_builtin_classify_type (tree);
  97 static void expand_errno_check (tree, rtx);
  98 static rtx expand_builtin_mathfn (tree, rtx, rtx);
  99 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
 100 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
 101 static rtx expand_builtin_mathfn_ternary (tree, rtx, rtx);
 102 static rtx expand_builtin_interclass_mathfn (tree, rtx);
 103 static rtx expand_builtin_sincos (tree);
 104 static rtx expand_builtin_cexpi (tree, rtx);
 105 static rtx expand_builtin_int_roundingfn (tree, rtx);
 106 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
 107 static rtx expand_builtin_next_arg (void);
 108 static rtx expand_builtin_va_start (tree);
 109 static rtx expand_builtin_va_end (tree);
 110 static rtx expand_builtin_va_copy (tree);
 111 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
 112 static rtx expand_builtin_strcmp (tree, rtx);
 113 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
 114 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 115 static rtx expand_builtin_memcpy (tree, rtx);
 116 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
 117 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
 118                                         enum machine_mode, int);
 119 static rtx expand_builtin_strcpy (tree, rtx);
 120 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
 121 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
 122 static rtx expand_builtin_strncpy (tree, rtx);
 123 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
 124 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
 125 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
 126 static rtx expand_builtin_bzero (tree);
 127 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
 128 static rtx expand_builtin_alloca (tree, bool);
 129 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
 130 static rtx expand_builtin_frame_address (tree, tree);
 131 static tree stabilize_va_list_loc (location_t, tree, int);
 132 static rtx expand_builtin_expect (tree, rtx);
 133 static tree fold_builtin_constant_p (tree);
 134 static tree fold_builtin_expect (location_t, tree, tree);
 135 static tree fold_builtin_classify_type (tree);
 136 static tree fold_builtin_strlen (location_t, tree, tree);
 137 static tree fold_builtin_inf (location_t, tree, int);
 138 static tree fold_builtin_nan (tree, tree, int);
 139 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
 140 static bool validate_arg (const_tree, enum tree_code code);
 141 static bool integer_valued_real_p (tree);
 142 static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
 143 static bool readonly_data_expr (tree);
 144 static rtx expand_builtin_fabs (tree, rtx, rtx);
 145 static rtx expand_builtin_signbit (tree, rtx);
 146 static tree fold_builtin_sqrt (location_t, tree, tree);
 147 static tree fold_builtin_cbrt (location_t, tree, tree);
 148 static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
 149 static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
 150 static tree fold_builtin_cos (location_t, tree, tree, tree);
 151 static tree fold_builtin_cosh (location_t, tree, tree, tree);
 152 static tree fold_builtin_tan (tree, tree);
 153 static tree fold_builtin_trunc (location_t, tree, tree);
 154 static tree fold_builtin_floor (location_t, tree, tree);
 155 static tree fold_builtin_ceil (location_t, tree, tree);
 156 static tree fold_builtin_round (location_t, tree, tree);
 157 static tree fold_builtin_int_roundingfn (location_t, tree, tree);
 158 static tree fold_builtin_bitop (tree, tree);
 159 static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
 160 static tree fold_builtin_strchr (location_t, tree, tree, tree);
 161 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
 162 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
 163 static tree fold_builtin_strcmp (location_t, tree, tree);
 164 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
 165 static tree fold_builtin_signbit (location_t, tree, tree);
 166 static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
 167 static tree fold_builtin_isascii (location_t, tree);
 168 static tree fold_builtin_toascii (location_t, tree);
 169 static tree fold_builtin_isdigit (location_t, tree);
 170 static tree fold_builtin_fabs (location_t, tree, tree);
 171 static tree fold_builtin_abs (location_t, tree, tree);
 172 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
 173                                         enum tree_code);
 174 static tree fold_builtin_n (location_t, tree, tree *, int, bool);
 175 static tree fold_builtin_0 (location_t, tree, bool);
 176 static tree fold_builtin_1 (location_t, tree, tree, bool);
 177 static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
 178 static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
 179 static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
 180 static tree fold_builtin_varargs (location_t, tree, tree, bool);
 181
 182 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
 183 static tree fold_builtin_strstr (location_t, tree, tree, tree);
 184 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
 185 static tree fold_builtin_strcat (location_t, tree, tree);
 186 static tree fold_builtin_strncat (location_t, tree, tree, tree);
 187 static tree fold_builtin_strspn (location_t, tree, tree);
 188 static tree fold_builtin_strcspn (location_t, tree, tree);
 189 static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
 190 static tree fold_builtin_snprintf (location_t, tree, tree, tree, tree, int);
 191
 192 static rtx expand_builtin_object_size (tree);
 193 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
 194                                       enum built_in_function);
 195 static void maybe_emit_chk_warning (tree, enum built_in_function);
 196 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 197 static void maybe_emit_free_warning (tree);
 198 static tree fold_builtin_object_size (tree, tree);
 199 static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
 200 static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
 201 static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
 202 static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
 203 static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
 204                                   enum built_in_function);
 205 static bool init_target_chars (void);
 206
 207 static unsigned HOST_WIDE_INT target_newline;
 208 static unsigned HOST_WIDE_INT target_percent;
 209 static unsigned HOST_WIDE_INT target_c;
 210 static unsigned HOST_WIDE_INT target_s;
 211 static char target_percent_c[3];
 212 static char target_percent_s[3];
 213 static char target_percent_s_newline[4];
 214 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
 215                           const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
 216 static tree do_mpfr_arg2 (tree, tree, tree,
 217                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 218 static tree do_mpfr_arg3 (tree, tree, tree, tree,
 219                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 220 static tree do_mpfr_sincos (tree, tree, tree);
 221 static tree do_mpfr_bessel_n (tree, tree, tree,
 222                               int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
 223                               const REAL_VALUE_TYPE *, bool);
 224 static tree do_mpfr_remquo (tree, tree, tree);
 225 static tree do_mpfr_lgamma_r (tree, tree, tree);
 226 static void expand_builtin_sync_synchronize (void);
 227
 228 /* Return true if NAME starts with __builtin_ or __sync_.  */
 229
 230 static bool
 231 is_builtin_name (const char *name)
 232 {
 233   if (strncmp (name, "__builtin_", 10) == 0)
 234     return true;
 235   if (strncmp (name, "__sync_", 7) == 0)
 236     return true;
 237   if (strncmp (name, "__atomic_", 9) == 0)
 238     return true;
 239   return false;
 240 }
 241
 242
 243 /* Return true if DECL is a function symbol representing a built-in.  */
 244
 245 bool
 246 is_builtin_fn (tree decl)
 247 {
 248   return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
 249 }
 250
 251
 252 /* Return true if NODE should be considered for inline expansion regardless
 253    of the optimization level.  This means whenever a function is invoked with
 254    its "internal" name, which normally contains the prefix "__builtin".  */
 255
 256 static bool
 257 called_as_built_in (tree node)
 258 {
 259   /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
 260      we want the name used to call the function, not the name it
 261      will have. */
 262   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 263   return is_builtin_name (name);
 264 }
 265
 266 /* Compute values M and N such that M divides (address of EXP - N) and
 267    such that N < M.  Store N in *BITPOSP and return M.
 268
 269    Note that the address (and thus the alignment) computed here is based
 270    on the address to which a symbol resolves, whereas DECL_ALIGN is based
 271    on the address at which an object is actually located.  These two
 272    addresses are not always the same.  For example, on ARM targets,
 273    the address &foo of a Thumb function foo() has the lowest bit set,
 274    whereas foo() itself starts on an even address.  */
 275
 276 unsigned int
 277 get_object_alignment_1 (tree exp, unsigned HOST_WIDE_INT *bitposp)
 278 {
 279   HOST_WIDE_INT bitsize, bitpos;
 280   tree offset;
 281   enum machine_mode mode;
 282   int unsignedp, volatilep;
 283   unsigned int align, inner;
 284
 285   /* Get the innermost object and the constant (bitpos) and possibly
 286      variable (offset) offset of the access.  */
 287   exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
 288                              &mode, &unsignedp, &volatilep, true);
 289
 290   /* Extract alignment information from the innermost object and
 291      possibly adjust bitpos and offset.  */
 292   if (TREE_CODE (exp) == CONST_DECL)
 293     exp = DECL_INITIAL (exp);
 294   if (DECL_P (exp)
 295       && TREE_CODE (exp) != LABEL_DECL)
 296     {
 297       if (TREE_CODE (exp) == FUNCTION_DECL)
 298         {
 299           /* Function addresses can encode extra information besides their
 300              alignment.  However, if TARGET_PTRMEMFUNC_VBIT_LOCATION
 301              allows the low bit to be used as a virtual bit, we know
 302              that the address itself must be 2-byte aligned.  */
 303           if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn)
 304             align = 2 * BITS_PER_UNIT;
 305           else
 306             align = BITS_PER_UNIT;
 307         }
 308       else
 309         align = DECL_ALIGN (exp);
 310     }
 311   else if (CONSTANT_CLASS_P (exp))
 312     {
 313       align = TYPE_ALIGN (TREE_TYPE (exp));
 314 #ifdef CONSTANT_ALIGNMENT
 315       align = (unsigned)CONSTANT_ALIGNMENT (exp, align);
 316 #endif
 317     }
 318   else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
 319     align = TYPE_ALIGN (TREE_TYPE (exp));
 320   else if (TREE_CODE (exp) == INDIRECT_REF)
 321     align = TYPE_ALIGN (TREE_TYPE (exp));
 322   else if (TREE_CODE (exp) == MEM_REF)
 323     {
 324       tree addr = TREE_OPERAND (exp, 0);
 325       struct ptr_info_def *pi;
 326       if (TREE_CODE (addr) == BIT_AND_EXPR
 327           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 328         {
 329           align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 330                     & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 331           align *= BITS_PER_UNIT;
 332           addr = TREE_OPERAND (addr, 0);
 333         }
 334       else
 335         align = BITS_PER_UNIT;
 336       if (TREE_CODE (addr) == SSA_NAME
 337           && (pi = SSA_NAME_PTR_INFO (addr)))
 338         {
 339           bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
 340           align = MAX (pi->align * BITS_PER_UNIT, align);
 341         }
 342       else if (TREE_CODE (addr) == ADDR_EXPR)
 343         align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0)));
 344       bitpos += mem_ref_offset (exp).low * BITS_PER_UNIT;
 345     }
 346   else if (TREE_CODE (exp) == TARGET_MEM_REF)
 347     {
 348       struct ptr_info_def *pi;
 349       tree addr = TMR_BASE (exp);
 350       if (TREE_CODE (addr) == BIT_AND_EXPR
 351           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 352         {
 353           align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 354                    & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 355           align *= BITS_PER_UNIT;
 356           addr = TREE_OPERAND (addr, 0);
 357         }
 358       else
 359         align = BITS_PER_UNIT;
 360       if (TREE_CODE (addr) == SSA_NAME
 361           && (pi = SSA_NAME_PTR_INFO (addr)))
 362         {
 363           bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
 364           align = MAX (pi->align * BITS_PER_UNIT, align);
 365         }
 366       else if (TREE_CODE (addr) == ADDR_EXPR)
 367         align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0)));
 368       if (TMR_OFFSET (exp))
 369         bitpos += TREE_INT_CST_LOW (TMR_OFFSET (exp)) * BITS_PER_UNIT;
 370       if (TMR_INDEX (exp) && TMR_STEP (exp))
 371         {
 372           unsigned HOST_WIDE_INT step = TREE_INT_CST_LOW (TMR_STEP (exp));
 373           align = MIN (align, (step & -step) * BITS_PER_UNIT);
 374         }
 375       else if (TMR_INDEX (exp))
 376         align = BITS_PER_UNIT;
 377       if (TMR_INDEX2 (exp))
 378         align = BITS_PER_UNIT;
 379     }
 380   else
 381     align = BITS_PER_UNIT;
 382
 383   /* If there is a non-constant offset part extract the maximum
 384      alignment that can prevail.  */
 385   inner = ~0U;
 386   while (offset)
 387     {
 388       tree next_offset;
 389
 390       if (TREE_CODE (offset) == PLUS_EXPR)
 391         {
 392           next_offset = TREE_OPERAND (offset, 0);
 393           offset = TREE_OPERAND (offset, 1);
 394         }
 395       else
 396         next_offset = NULL;
 397       if (host_integerp (offset, 1))
 398         {
 399           /* Any overflow in calculating offset_bits won't change
 400              the alignment.  */
 401           unsigned offset_bits
 402             = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
 403
 404           if (offset_bits)
 405             inner = MIN (inner, (offset_bits & -offset_bits));
 406         }
 407       else if (TREE_CODE (offset) == MULT_EXPR
 408                && host_integerp (TREE_OPERAND (offset, 1), 1))
 409         {
 410           /* Any overflow in calculating offset_factor won't change
 411              the alignment.  */
 412           unsigned offset_factor
 413             = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
 414                * BITS_PER_UNIT);
 415
 416           if (offset_factor)
 417             inner = MIN (inner, (offset_factor & -offset_factor));
 418         }
 419       else
 420         {
 421           inner = MIN (inner, BITS_PER_UNIT);
 422           break;
 423         }
 424       offset = next_offset;
 425     }
 426
 427   /* Alignment is innermost object alignment adjusted by the constant
 428      and non-constant offset parts.  */
 429   align = MIN (align, inner);
 430   bitpos = bitpos & (align - 1);
 431
 432   *bitposp = bitpos;
 433   return align;
 434 }
 435
 436 /* Return the alignment in bits of EXP, an object.  */
 437
 438 unsigned int
 439 get_object_alignment (tree exp)
 440 {
 441   unsigned HOST_WIDE_INT bitpos = 0;
 442   unsigned int align;
 443
 444   align = get_object_alignment_1 (exp, &bitpos);
 445
 446   /* align and bitpos now specify known low bits of the pointer.
 447      ptr & (align - 1) == bitpos.  */
 448
 449   if (bitpos != 0)
 450     align = (bitpos & -bitpos);
 451
 452   return align;
 453 }
 454
 455 /* Return the alignment of object EXP, also considering its type when we do
 456    not know of explicit misalignment.  Only handle MEM_REF and TARGET_MEM_REF.
 457
 458    ??? Note that, in the general case, the type of an expression is not kept
 459    consistent with misalignment information by the front-end, for example when
 460    taking the address of a member of a packed structure.  However, in most of
 461    the cases, expressions have the alignment of their type so we optimistically
 462    fall back to this alignment when we cannot compute a misalignment.  */
 463
 464 unsigned int
 465 get_object_or_type_alignment (tree exp)
 466 {
 467   unsigned HOST_WIDE_INT misalign;
 468   unsigned int align = get_object_alignment_1 (exp, &misalign);
 469
 470   gcc_assert (TREE_CODE (exp) == MEM_REF || TREE_CODE (exp) == TARGET_MEM_REF);
 471
 472   if (misalign != 0)
 473     align = (misalign & -misalign);
 474   else
 475     align = MAX (TYPE_ALIGN (TREE_TYPE (exp)), align);
 476
 477   return align;
 478 }
 479
 480 /* For a pointer valued expression EXP compute values M and N such that
 481    M divides (EXP - N) and such that N < M.  Store N in *BITPOSP and return M.
 482
 483    If EXP is not a pointer, 0 is returned.  */
 484
 485 unsigned int
 486 get_pointer_alignment_1 (tree exp, unsigned HOST_WIDE_INT *bitposp)
 487 {
 488   STRIP_NOPS (exp);
 489
 490   if (TREE_CODE (exp) == ADDR_EXPR)
 491     return get_object_alignment_1 (TREE_OPERAND (exp, 0), bitposp);
 492   else if (TREE_CODE (exp) == SSA_NAME
 493            && POINTER_TYPE_P (TREE_TYPE (exp)))
 494     {
 495       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);
 496       if (!pi)
 497         {
 498           *bitposp = 0;
 499           return BITS_PER_UNIT;
 500         }
 501       *bitposp = pi->misalign * BITS_PER_UNIT;
 502       return pi->align * BITS_PER_UNIT;
 503     }
 504
 505   *bitposp = 0;
 506   return POINTER_TYPE_P (TREE_TYPE (exp)) ? BITS_PER_UNIT : 0;
 507 }
 508
 509 /* Return the alignment in bits of EXP, a pointer valued expression.
 510    The alignment returned is, by default, the alignment of the thing that
 511    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 512
 513    Otherwise, look at the expression to see if we can do better, i.e., if the
 514    expression is actually pointing at an object whose alignment is tighter.  */
 515
 516 unsigned int
 517 get_pointer_alignment (tree exp)
 518 {
 519   unsigned HOST_WIDE_INT bitpos = 0;
 520   unsigned int align;
 521
 522   align = get_pointer_alignment_1 (exp, &bitpos);
 523
 524   /* align and bitpos now specify known low bits of the pointer.
 525      ptr & (align - 1) == bitpos.  */
 526
 527   if (bitpos != 0)
 528     align = (bitpos & -bitpos);
 529
 530   return align;
 531 }
 532
 533 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 534    way, because it could contain a zero byte in the middle.
 535    TREE_STRING_LENGTH is the size of the character array, not the string.
 536
 537    ONLY_VALUE should be nonzero if the result is not going to be emitted
 538    into the instruction stream and zero if it is going to be expanded.
 539    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 540    is returned, otherwise NULL, since
 541    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
 542    evaluate the side-effects.
 543
 544    The value returned is of type `ssizetype'.
 545
 546    Unfortunately, string_constant can't access the values of const char
 547    arrays with initializers, so neither can we do so here.  */
 548
 549 tree
 550 c_strlen (tree src, int only_value)
 551 {
 552   tree offset_node;
 553   HOST_WIDE_INT offset;
 554   int max;
 555   const char *ptr;
 556   location_t loc;
 557
 558   STRIP_NOPS (src);
 559   if (TREE_CODE (src) == COND_EXPR
 560       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 561     {
 562       tree len1, len2;
 563
 564       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
 565       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
 566       if (tree_int_cst_equal (len1, len2))
 567         return len1;
 568     }
 569
 570   if (TREE_CODE (src) == COMPOUND_EXPR
 571       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 572     return c_strlen (TREE_OPERAND (src, 1), only_value);
 573
 574   loc = EXPR_LOC_OR_HERE (src);
 575
 576   src = string_constant (src, &offset_node);
 577   if (src == 0)
 578     return NULL_TREE;
 579
 580   max = TREE_STRING_LENGTH (src) - 1;
 581   ptr = TREE_STRING_POINTER (src);
 582
 583   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 584     {
 585       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 586          compute the offset to the following null if we don't know where to
 587          start searching for it.  */
 588       int i;
 589
 590       for (i = 0; i < max; i++)
 591         if (ptr[i] == 0)
 592           return NULL_TREE;
 593
 594       /* We don't know the starting offset, but we do know that the string
 595          has no internal zero bytes.  We can assume that the offset falls
 596          within the bounds of the string; otherwise, the programmer deserves
 597          what he gets.  Subtract the offset from the length of the string,
 598          and return that.  This would perhaps not be valid if we were dealing
 599          with named arrays in addition to literal string constants.  */
 600
 601       return size_diffop_loc (loc, size_int (max), offset_node);
 602     }
 603
 604   /* We have a known offset into the string.  Start searching there for
 605      a null character if we can represent it as a single HOST_WIDE_INT.  */
 606   if (offset_node == 0)
 607     offset = 0;
 608   else if (! host_integerp (offset_node, 0))
 609     offset = -1;
 610   else
 611     offset = tree_low_cst (offset_node, 0);
 612
 613   /* If the offset is known to be out of bounds, warn, and call strlen at
 614      runtime.  */
 615   if (offset < 0 || offset > max)
 616     {
 617      /* Suppress multiple warnings for propagated constant strings.  */
 618       if (! TREE_NO_WARNING (src))
 619         {
 620           warning_at (loc, 0, "offset outside bounds of constant string");
 621           TREE_NO_WARNING (src) = 1;
 622         }
 623       return NULL_TREE;
 624     }
 625
 626   /* Use strlen to search for the first zero byte.  Since any strings
 627      constructed with build_string will have nulls appended, we win even
 628      if we get handed something like (char[4])"abcd".
 629
 630      Since OFFSET is our starting index into the string, no further
 631      calculation is needed.  */
 632   return ssize_int (strlen (ptr + offset));
 633 }
 634
 635 /* Return a char pointer for a C string if it is a string constant
 636    or sum of string constant and integer constant.  */
 637
 638 static const char *
 639 c_getstr (tree src)
 640 {
 641   tree offset_node;
 642
 643   src = string_constant (src, &offset_node);
 644   if (src == 0)
 645     return 0;
 646
 647   if (offset_node == 0)
 648     return TREE_STRING_POINTER (src);
 649   else if (!host_integerp (offset_node, 1)
 650            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
 651     return 0;
 652
 653   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
 654 }
 655
 656 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
 657    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 658
 659 static rtx
 660 c_readstr (const char *str, enum machine_mode mode)
 661 {
 662   HOST_WIDE_INT c[2];
 663   HOST_WIDE_INT ch;
 664   unsigned int i, j;
 665
 666   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
 667
 668   c[0] = 0;
 669   c[1] = 0;
 670   ch = 1;
 671   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 672     {
 673       j = i;
 674       if (WORDS_BIG_ENDIAN)
 675         j = GET_MODE_SIZE (mode) - i - 1;
 676       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 677           && GET_MODE_SIZE (mode) >= UNITS_PER_WORD)
 678         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 679       j *= BITS_PER_UNIT;
 680       gcc_assert (j < 2 * HOST_BITS_PER_WIDE_INT);
 681
 682       if (ch)
 683         ch = (unsigned char) str[i];
 684       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 685     }
 686   return immed_double_const (c[0], c[1], mode);
 687 }
 688
 689 /* Cast a target constant CST to target CHAR and if that value fits into
 690    host char type, return zero and put that value into variable pointed to by
 691    P.  */
 692
 693 static int
 694 target_char_cast (tree cst, char *p)
 695 {
 696   unsigned HOST_WIDE_INT val, hostval;
 697
 698   if (TREE_CODE (cst) != INTEGER_CST
 699       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 700     return 1;
 701
 702   val = TREE_INT_CST_LOW (cst);
 703   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 704     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 705
 706   hostval = val;
 707   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 708     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 709
 710   if (val != hostval)
 711     return 1;
 712
 713   *p = hostval;
 714   return 0;
 715 }
 716
 717 /* Similar to save_expr, but assumes that arbitrary code is not executed
 718    in between the multiple evaluations.  In particular, we assume that a
 719    non-addressable local variable will not be modified.  */
 720
 721 static tree
 722 builtin_save_expr (tree exp)
 723 {
 724   if (TREE_CODE (exp) == SSA_NAME
 725       || (TREE_ADDRESSABLE (exp) == 0
 726           && (TREE_CODE (exp) == PARM_DECL
 727               || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp)))))
 728     return exp;
 729
 730   return save_expr (exp);
 731 }
 732
 733 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 734    times to get the address of either a higher stack frame, or a return
 735    address located within it (depending on FNDECL_CODE).  */
 736
 737 static rtx
 738 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
 739 {
 740   int i;
 741
 742 #ifdef INITIAL_FRAME_ADDRESS_RTX
 743   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
 744 #else
 745   rtx tem;
 746
 747   /* For a zero count with __builtin_return_address, we don't care what
 748      frame address we return, because target-specific definitions will
 749      override us.  Therefore frame pointer elimination is OK, and using
 750      the soft frame pointer is OK.
 751
 752      For a nonzero count, or a zero count with __builtin_frame_address,
 753      we require a stable offset from the current frame pointer to the
 754      previous one, so we must use the hard frame pointer, and
 755      we must disable frame pointer elimination.  */
 756   if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
 757     tem = frame_pointer_rtx;
 758   else
 759     {
 760       tem = hard_frame_pointer_rtx;
 761
 762       /* Tell reload not to eliminate the frame pointer.  */
 763       crtl->accesses_prior_frames = 1;
 764     }
 765 #endif
 766
 767   /* Some machines need special handling before we can access
 768      arbitrary frames.  For example, on the SPARC, we must first flush
 769      all register windows to the stack.  */
 770 #ifdef SETUP_FRAME_ADDRESSES
 771   if (count > 0)
 772     SETUP_FRAME_ADDRESSES ();
 773 #endif
 774
 775   /* On the SPARC, the return address is not in the frame, it is in a
 776      register.  There is no way to access it off of the current frame
 777      pointer, but it can be accessed off the previous frame pointer by
 778      reading the value from the register window save area.  */
 779 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
 780   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
 781     count--;
 782 #endif
 783
 784   /* Scan back COUNT frames to the specified frame.  */
 785   for (i = 0; i < count; i++)
 786     {
 787       /* Assume the dynamic chain pointer is in the word that the
 788          frame address points to, unless otherwise specified.  */
 789 #ifdef DYNAMIC_CHAIN_ADDRESS
 790       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 791 #endif
 792       tem = memory_address (Pmode, tem);
 793       tem = gen_frame_mem (Pmode, tem);
 794       tem = copy_to_reg (tem);
 795     }
 796
 797   /* For __builtin_frame_address, return what we've got.  But, on
 798      the SPARC for example, we may have to add a bias.  */
 799   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 800 #ifdef FRAME_ADDR_RTX
 801     return FRAME_ADDR_RTX (tem);
 802 #else
 803     return tem;
 804 #endif
 805
 806   /* For __builtin_return_address, get the return address from that frame.  */
 807 #ifdef RETURN_ADDR_RTX
 808   tem = RETURN_ADDR_RTX (count, tem);
 809 #else
 810   tem = memory_address (Pmode,
 811                         plus_constant (tem, GET_MODE_SIZE (Pmode)));
 812   tem = gen_frame_mem (Pmode, tem);
 813 #endif
 814   return tem;
 815 }
 816
 817 /* Alias set used for setjmp buffer.  */
 818 static alias_set_type setjmp_alias_set = -1;
 819
 820 /* Construct the leading half of a __builtin_setjmp call.  Control will
 821    return to RECEIVER_LABEL.  This is also called directly by the SJLJ
 822    exception handling code.  */
 823
 824 void
 825 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 826 {
 827   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 828   rtx stack_save;
 829   rtx mem;
 830
 831   if (setjmp_alias_set == -1)
 832     setjmp_alias_set = new_alias_set ();
 833
 834   buf_addr = convert_memory_address (Pmode, buf_addr);
 835
 836   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 837
 838   /* We store the frame pointer and the address of receiver_label in
 839      the buffer and use the rest of it for the stack save area, which
 840      is machine-dependent.  */
 841
 842   mem = gen_rtx_MEM (Pmode, buf_addr);
 843   set_mem_alias_set (mem, setjmp_alias_set);
 844   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
 845
 846   mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
 847   set_mem_alias_set (mem, setjmp_alias_set);
 848
 849   emit_move_insn (validize_mem (mem),
 850                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 851
 852   stack_save = gen_rtx_MEM (sa_mode,
 853                             plus_constant (buf_addr,
 854                                            2 * GET_MODE_SIZE (Pmode)));
 855   set_mem_alias_set (stack_save, setjmp_alias_set);
 856   emit_stack_save (SAVE_NONLOCAL, &stack_save);
 857
 858   /* If there is further processing to do, do it.  */
 859 #ifdef HAVE_builtin_setjmp_setup
 860   if (HAVE_builtin_setjmp_setup)
 861     emit_insn (gen_builtin_setjmp_setup (buf_addr));
 862 #endif
 863
 864   /* We have a nonlocal label.   */
 865   cfun->has_nonlocal_label = 1;
 866 }
 867
 868 /* Construct the trailing part of a __builtin_setjmp call.  This is
 869    also called directly by the SJLJ exception handling code.  */
 870
 871 void
 872 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
 873 {
 874   rtx chain;
 875
 876   /* Clobber the FP when we get here, so we have to make sure it's
 877      marked as used by this function.  */
 878   emit_use (hard_frame_pointer_rtx);
 879
 880   /* Mark the static chain as clobbered here so life information
 881      doesn't get messed up for it.  */
 882   chain = targetm.calls.static_chain (current_function_decl, true);
 883   if (chain && REG_P (chain))
 884     emit_clobber (chain);
 885
 886   /* Now put in the code to restore the frame pointer, and argument
 887      pointer, if needed.  */
 888 #ifdef HAVE_nonlocal_goto
 889   if (! HAVE_nonlocal_goto)
 890 #endif
 891     {
 892       emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 893       /* This might change the hard frame pointer in ways that aren't
 894          apparent to early optimization passes, so force a clobber.  */
 895       emit_clobber (hard_frame_pointer_rtx);
 896     }
 897
 898 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
 899   if (fixed_regs[ARG_POINTER_REGNUM])
 900     {
 901 #ifdef ELIMINABLE_REGS
 902       size_t i;
 903       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 904
 905       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 906         if (elim_regs[i].from == ARG_POINTER_REGNUM
 907             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 908           break;
 909
 910       if (i == ARRAY_SIZE (elim_regs))
 911 #endif
 912         {
 913           /* Now restore our arg pointer from the address at which it
 914              was saved in our stack frame.  */
 915           emit_move_insn (crtl->args.internal_arg_pointer,
 916                           copy_to_reg (get_arg_pointer_save_area ()));
 917         }
 918     }
 919 #endif
 920
 921 #ifdef HAVE_builtin_setjmp_receiver
 922   if (HAVE_builtin_setjmp_receiver)
 923     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
 924   else
 925 #endif
 926 #ifdef HAVE_nonlocal_goto_receiver
 927     if (HAVE_nonlocal_goto_receiver)
 928       emit_insn (gen_nonlocal_goto_receiver ());
 929     else
 930 #endif
 931       { /* Nothing */ }
 932
 933   /* We must not allow the code we just generated to be reordered by
 934      scheduling.  Specifically, the update of the frame pointer must
 935      happen immediately, not later.  */
 936   emit_insn (gen_blockage ());
 937 }
 938
 939 /* __builtin_longjmp is passed a pointer to an array of five words (not
 940    all will be used on all machines).  It operates similarly to the C
 941    library function of the same name, but is more efficient.  Much of
 942    the code below is copied from the handling of non-local gotos.  */
 943
 944 static void
 945 expand_builtin_longjmp (rtx buf_addr, rtx value)
 946 {
 947   rtx fp, lab, stack, insn, last;
 948   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 949
 950   /* DRAP is needed for stack realign if longjmp is expanded to current
 951      function  */
 952   if (SUPPORTS_STACK_ALIGNMENT)
 953     crtl->need_drap = true;
 954
 955   if (setjmp_alias_set == -1)
 956     setjmp_alias_set = new_alias_set ();
 957
 958   buf_addr = convert_memory_address (Pmode, buf_addr);
 959
 960   buf_addr = force_reg (Pmode, buf_addr);
 961
 962   /* We require that the user must pass a second argument of 1, because
 963      that is what builtin_setjmp will return.  */
 964   gcc_assert (value == const1_rtx);
 965
 966   last = get_last_insn ();
 967 #ifdef HAVE_builtin_longjmp
 968   if (HAVE_builtin_longjmp)
 969     emit_insn (gen_builtin_longjmp (buf_addr));
 970   else
 971 #endif
 972     {
 973       fp = gen_rtx_MEM (Pmode, buf_addr);
 974       lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
 975                                                GET_MODE_SIZE (Pmode)));
 976
 977       stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
 978                                                    2 * GET_MODE_SIZE (Pmode)));
 979       set_mem_alias_set (fp, setjmp_alias_set);
 980       set_mem_alias_set (lab, setjmp_alias_set);
 981       set_mem_alias_set (stack, setjmp_alias_set);
 982
 983       /* Pick up FP, label, and SP from the block and jump.  This code is
 984          from expand_goto in stmt.c; see there for detailed comments.  */
 985 #ifdef HAVE_nonlocal_goto
 986       if (HAVE_nonlocal_goto)
 987         /* We have to pass a value to the nonlocal_goto pattern that will
 988            get copied into the static_chain pointer, but it does not matter
 989            what that value is, because builtin_setjmp does not use it.  */
 990         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
 991       else
 992 #endif
 993         {
 994           lab = copy_to_reg (lab);
 995
 996           emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 997           emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 998
 999           emit_move_insn (hard_frame_pointer_rtx, fp);
1000           emit_stack_restore (SAVE_NONLOCAL, stack);
1001
1002           emit_use (hard_frame_pointer_rtx);
1003           emit_use (stack_pointer_rtx);
1004           emit_indirect_jump (lab);
1005         }
1006     }
1007
1008   /* Search backwards and mark the jump insn as a non-local goto.
1009      Note that this precludes the use of __builtin_longjmp to a
1010      __builtin_setjmp target in the same function.  However, we've
1011      already cautioned the user that these functions are for
1012      internal exception handling use only.  */
1013   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1014     {
1015       gcc_assert (insn != last);
1016
1017       if (JUMP_P (insn))
1018         {
1019           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1020           break;
1021         }
1022       else if (CALL_P (insn))
1023         break;
1024     }
1025 }
1026
1027 /* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
1028    and the address of the save area.  */
1029
1030 static rtx
1031 expand_builtin_nonlocal_goto (tree exp)
1032 {
1033   tree t_label, t_save_area;
1034   rtx r_label, r_save_area, r_fp, r_sp, insn;
1035
1036   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
1037     return NULL_RTX;
1038
1039   t_label = CALL_EXPR_ARG (exp, 0);
1040   t_save_area = CALL_EXPR_ARG (exp, 1);
1041
1042   r_label = expand_normal (t_label);
1043   r_label = convert_memory_address (Pmode, r_label);
1044   r_save_area = expand_normal (t_save_area);
1045   r_save_area = convert_memory_address (Pmode, r_save_area);
1046   /* Copy the address of the save location to a register just in case it was
1047      based on the frame pointer.   */
1048   r_save_area = copy_to_reg (r_save_area);
1049   r_fp = gen_rtx_MEM (Pmode, r_save_area);
1050   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
1051                       plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
1052
1053   crtl->has_nonlocal_goto = 1;
1054
1055 #ifdef HAVE_nonlocal_goto
1056   /* ??? We no longer need to pass the static chain value, afaik.  */
1057   if (HAVE_nonlocal_goto)
1058     emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
1059   else
1060 #endif
1061     {
1062       r_label = copy_to_reg (r_label);
1063
1064       emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1065       emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1066
1067       /* Restore frame pointer for containing function.  */
1068       emit_move_insn (hard_frame_pointer_rtx, r_fp);
1069       emit_stack_restore (SAVE_NONLOCAL, r_sp);
1070
1071       /* USE of hard_frame_pointer_rtx added for consistency;
1072          not clear if really needed.  */
1073       emit_use (hard_frame_pointer_rtx);
1074       emit_use (stack_pointer_rtx);
1075
1076       /* If the architecture is using a GP register, we must
1077          conservatively assume that the target function makes use of it.
1078          The prologue of functions with nonlocal gotos must therefore
1079          initialize the GP register to the appropriate value, and we
1080          must then make sure that this value is live at the point
1081          of the jump.  (Note that this doesn't necessarily apply
1082          to targets with a nonlocal_goto pattern; they are free
1083          to implement it in their own way.  Note also that this is
1084          a no-op if the GP register is a global invariant.)  */
1085       if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
1086           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
1087         emit_use (pic_offset_table_rtx);
1088
1089       emit_indirect_jump (r_label);
1090     }
1091
1092   /* Search backwards to the jump insn and mark it as a
1093      non-local goto.  */
1094   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1095     {
1096       if (JUMP_P (insn))
1097         {
1098           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1099           break;
1100         }
1101       else if (CALL_P (insn))
1102         break;
1103     }
1104
1105   return const0_rtx;
1106 }
1107
1108 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1109    (not all will be used on all machines) that was passed to __builtin_setjmp.
1110    It updates the stack pointer in that block to correspond to the current
1111    stack pointer.  */
1112
1113 static void
1114 expand_builtin_update_setjmp_buf (rtx buf_addr)
1115 {
1116   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1117   rtx stack_save
1118     = gen_rtx_MEM (sa_mode,
1119                    memory_address
1120                    (sa_mode,
1121                     plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1122
1123   emit_stack_save (SAVE_NONLOCAL, &stack_save);
1124 }
1125
1126 /* Expand a call to __builtin_prefetch.  For a target that does not support
1127    data prefetch, evaluate the memory address argument in case it has side
1128    effects.  */
1129
1130 static void
1131 expand_builtin_prefetch (tree exp)
1132 {
1133   tree arg0, arg1, arg2;
1134   int nargs;
1135   rtx op0, op1, op2;
1136
1137   if (!validate_arglist (exp, POINTER_TYPE, 0))
1138     return;
1139
1140   arg0 = CALL_EXPR_ARG (exp, 0);
1141
1142   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1143      zero (read) and argument 2 (locality) defaults to 3 (high degree of
1144      locality).  */
1145   nargs = call_expr_nargs (exp);
1146   if (nargs > 1)
1147     arg1 = CALL_EXPR_ARG (exp, 1);
1148   else
1149     arg1 = integer_zero_node;
1150   if (nargs > 2)
1151     arg2 = CALL_EXPR_ARG (exp, 2);
1152   else
1153     arg2 = integer_three_node;
1154
1155   /* Argument 0 is an address.  */
1156   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1157
1158   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
1159   if (TREE_CODE (arg1) != INTEGER_CST)
1160     {
1161       error ("second argument to %<__builtin_prefetch%> must be a constant");
1162       arg1 = integer_zero_node;
1163     }
1164   op1 = expand_normal (arg1);
1165   /* Argument 1 must be either zero or one.  */
1166   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1167     {
1168       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1169                " using zero");
1170       op1 = const0_rtx;
1171     }
1172
1173   /* Argument 2 (locality) must be a compile-time constant int.  */
1174   if (TREE_CODE (arg2) != INTEGER_CST)
1175     {
1176       error ("third argument to %<__builtin_prefetch%> must be a constant");
1177       arg2 = integer_zero_node;
1178     }
1179   op2 = expand_normal (arg2);
1180   /* Argument 2 must be 0, 1, 2, or 3.  */
1181   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1182     {
1183       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1184       op2 = const0_rtx;
1185     }
1186
1187 #ifdef HAVE_prefetch
1188   if (HAVE_prefetch)
1189     {
1190       struct expand_operand ops[3];
1191
1192       create_address_operand (&ops[0], op0);
1193       create_integer_operand (&ops[1], INTVAL (op1));
1194       create_integer_operand (&ops[2], INTVAL (op2));
1195       if (maybe_expand_insn (CODE_FOR_prefetch, 3, ops))
1196         return;
1197     }
1198 #endif
1199
1200   /* Don't do anything with direct references to volatile memory, but
1201      generate code to handle other side effects.  */
1202   if (!MEM_P (op0) && side_effects_p (op0))
1203     emit_insn (op0);
1204 }
1205
1206 /* Get a MEM rtx for expression EXP which is the address of an operand
1207    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1208    the maximum length of the block of memory that might be accessed or
1209    NULL if unknown.  */
1210
1211 static rtx
1212 get_memory_rtx (tree exp, tree len)
1213 {
1214   tree orig_exp = exp;
1215   rtx addr, mem;
1216   HOST_WIDE_INT off;
1217
1218   /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1219      from its expression, for expr->a.b only <variable>.a.b is recorded.  */
1220   if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1221     exp = TREE_OPERAND (exp, 0);
1222
1223   addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1224   mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1225
1226   /* Get an expression we can use to find the attributes to assign to MEM.
1227      If it is an ADDR_EXPR, use the operand.  Otherwise, dereference it if
1228      we can.  First remove any nops.  */
1229   while (CONVERT_EXPR_P (exp)
1230          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1231     exp = TREE_OPERAND (exp, 0);
1232
1233   off = 0;
1234   if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1235       && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1236       && host_integerp (TREE_OPERAND (exp, 1), 0)
1237       && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1238     exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1239   else if (TREE_CODE (exp) == ADDR_EXPR)
1240     exp = TREE_OPERAND (exp, 0);
1241   else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1242     exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1243   else
1244     exp = NULL;
1245
1246   /* Honor attributes derived from exp, except for the alias set
1247      (as builtin stringops may alias with anything) and the size
1248      (as stringops may access multiple array elements).  */
1249   if (exp)
1250     {
1251       set_mem_attributes (mem, exp, 0);
1252
1253       if (off)
1254         mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1255
1256       /* Allow the string and memory builtins to overflow from one
1257          field into another, see http://gcc.gnu.org/PR23561.
1258          Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1259          memory accessed by the string or memory builtin will fit
1260          within the field.  */
1261       if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1262         {
1263           tree mem_expr = MEM_EXPR (mem);
1264           HOST_WIDE_INT offset = -1, length = -1;
1265           tree inner = exp;
1266
1267           while (TREE_CODE (inner) == ARRAY_REF
1268                  || CONVERT_EXPR_P (inner)
1269                  || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1270                  || TREE_CODE (inner) == SAVE_EXPR)
1271             inner = TREE_OPERAND (inner, 0);
1272
1273           gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1274
1275           if (MEM_OFFSET_KNOWN_P (mem))
1276             offset = MEM_OFFSET (mem);
1277
1278           if (offset >= 0 && len && host_integerp (len, 0))
1279             length = tree_low_cst (len, 0);
1280
1281           while (TREE_CODE (inner) == COMPONENT_REF)
1282             {
1283               tree field = TREE_OPERAND (inner, 1);
1284               gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1285               gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1286
1287               /* Bitfields are generally not byte-addressable.  */
1288               gcc_assert (!DECL_BIT_FIELD (field)
1289                           || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1290                                % BITS_PER_UNIT) == 0
1291                               && host_integerp (DECL_SIZE (field), 0)
1292                               && (TREE_INT_CST_LOW (DECL_SIZE (field))
1293                                   % BITS_PER_UNIT) == 0));
1294
1295               /* If we can prove that the memory starting at XEXP (mem, 0) and
1296                  ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1297                  can keep the COMPONENT_REF in MEM_EXPR.  But be careful with
1298                  fields without DECL_SIZE_UNIT like flexible array members.  */
1299               if (length >= 0
1300                   && DECL_SIZE_UNIT (field)
1301                   && host_integerp (DECL_SIZE_UNIT (field), 0))
1302                 {
1303                   HOST_WIDE_INT size
1304                     = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1305                   if (offset <= size
1306                       && length <= size
1307                       && offset + length <= size)
1308                     break;
1309                 }
1310
1311               if (offset >= 0
1312                   && host_integerp (DECL_FIELD_OFFSET (field), 0))
1313                 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1314                           + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1315                             / BITS_PER_UNIT;
1316               else
1317                 {
1318                   offset = -1;
1319                   length = -1;
1320                 }
1321
1322               mem_expr = TREE_OPERAND (mem_expr, 0);
1323               inner = TREE_OPERAND (inner, 0);
1324             }
1325
1326           if (mem_expr == NULL)
1327             offset = -1;
1328           if (mem_expr != MEM_EXPR (mem))
1329             {
1330               set_mem_expr (mem, mem_expr);
1331               if (offset >= 0)
1332                 set_mem_offset (mem, offset);
1333               else
1334                 clear_mem_offset (mem);
1335             }
1336         }
1337       set_mem_alias_set (mem, 0);
1338       clear_mem_size (mem);
1339     }
1340
1341   return mem;
1342 }
1343 \f
1344 /* Built-in functions to perform an untyped call and return.  */
1345
1346 #define apply_args_mode \
1347   (this_target_builtins->x_apply_args_mode)
1348 #define apply_result_mode \
1349   (this_target_builtins->x_apply_result_mode)
1350
1351 /* Return the size required for the block returned by __builtin_apply_args,
1352    and initialize apply_args_mode.  */
1353
1354 static int
1355 apply_args_size (void)
1356 {
1357   static int size = -1;
1358   int align;
1359   unsigned int regno;
1360   enum machine_mode mode;
1361
1362   /* The values computed by this function never change.  */
1363   if (size < 0)
1364     {
1365       /* The first value is the incoming arg-pointer.  */
1366       size = GET_MODE_SIZE (Pmode);
1367
1368       /* The second value is the structure value address unless this is
1369          passed as an "invisible" first argument.  */
1370       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1371         size += GET_MODE_SIZE (Pmode);
1372
1373       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1374         if (FUNCTION_ARG_REGNO_P (regno))
1375           {
1376             mode = targetm.calls.get_raw_arg_mode (regno);
1377
1378             gcc_assert (mode != VOIDmode);
1379
1380             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1381             if (size % align != 0)
1382               size = CEIL (size, align) * align;
1383             size += GET_MODE_SIZE (mode);
1384             apply_args_mode[regno] = mode;
1385           }
1386         else
1387           {
1388             apply_args_mode[regno] = VOIDmode;
1389           }
1390     }
1391   return size;
1392 }
1393
1394 /* Return the size required for the block returned by __builtin_apply,
1395    and initialize apply_result_mode.  */
1396
1397 static int
1398 apply_result_size (void)
1399 {
1400   static int size = -1;
1401   int align, regno;
1402   enum machine_mode mode;
1403
1404   /* The values computed by this function never change.  */
1405   if (size < 0)
1406     {
1407       size = 0;
1408
1409       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1410         if (targetm.calls.function_value_regno_p (regno))
1411           {
1412             mode = targetm.calls.get_raw_result_mode (regno);
1413
1414             gcc_assert (mode != VOIDmode);
1415
1416             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1417             if (size % align != 0)
1418               size = CEIL (size, align) * align;
1419             size += GET_MODE_SIZE (mode);
1420             apply_result_mode[regno] = mode;
1421           }
1422         else
1423           apply_result_mode[regno] = VOIDmode;
1424
1425       /* Allow targets that use untyped_call and untyped_return to override
1426          the size so that machine-specific information can be stored here.  */
1427 #ifdef APPLY_RESULT_SIZE
1428       size = APPLY_RESULT_SIZE;
1429 #endif
1430     }
1431   return size;
1432 }
1433
1434 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1435 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1436    the result block is used to save the values; otherwise it is used to
1437    restore the values.  */
1438
1439 static rtx
1440 result_vector (int savep, rtx result)
1441 {
1442   int regno, size, align, nelts;
1443   enum machine_mode mode;
1444   rtx reg, mem;
1445   rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1446
1447   size = nelts = 0;
1448   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1449     if ((mode = apply_result_mode[regno]) != VOIDmode)
1450       {
1451         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1452         if (size % align != 0)
1453           size = CEIL (size, align) * align;
1454         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1455         mem = adjust_address (result, mode, size);
1456         savevec[nelts++] = (savep
1457                             ? gen_rtx_SET (VOIDmode, mem, reg)
1458                             : gen_rtx_SET (VOIDmode, reg, mem));
1459         size += GET_MODE_SIZE (mode);
1460       }
1461   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1462 }
1463 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1464
1465 /* Save the state required to perform an untyped call with the same
1466    arguments as were passed to the current function.  */
1467
1468 static rtx
1469 expand_builtin_apply_args_1 (void)
1470 {
1471   rtx registers, tem;
1472   int size, align, regno;
1473   enum machine_mode mode;
1474   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1475
1476   /* Create a block where the arg-pointer, structure value address,
1477      and argument registers can be saved.  */
1478   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1479
1480   /* Walk past the arg-pointer and structure value address.  */
1481   size = GET_MODE_SIZE (Pmode);
1482   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1483     size += GET_MODE_SIZE (Pmode);
1484
1485   /* Save each register used in calling a function to the block.  */
1486   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1487     if ((mode = apply_args_mode[regno]) != VOIDmode)
1488       {
1489         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1490         if (size % align != 0)
1491           size = CEIL (size, align) * align;
1492
1493         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1494
1495         emit_move_insn (adjust_address (registers, mode, size), tem);
1496         size += GET_MODE_SIZE (mode);
1497       }
1498
1499   /* Save the arg pointer to the block.  */
1500   tem = copy_to_reg (crtl->args.internal_arg_pointer);
1501 #ifdef STACK_GROWS_DOWNWARD
1502   /* We need the pointer as the caller actually passed them to us, not
1503      as we might have pretended they were passed.  Make sure it's a valid
1504      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1505   tem
1506     = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1507                      NULL_RTX);
1508 #endif
1509   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1510
1511   size = GET_MODE_SIZE (Pmode);
1512
1513   /* Save the structure value address unless this is passed as an
1514      "invisible" first argument.  */
1515   if (struct_incoming_value)
1516     {
1517       emit_move_insn (adjust_address (registers, Pmode, size),
1518                       copy_to_reg (struct_incoming_value));
1519       size += GET_MODE_SIZE (Pmode);
1520     }
1521
1522   /* Return the address of the block.  */
1523   return copy_addr_to_reg (XEXP (registers, 0));
1524 }
1525
1526 /* __builtin_apply_args returns block of memory allocated on
1527    the stack into which is stored the arg pointer, structure
1528    value address, static chain, and all the registers that might
1529    possibly be used in performing a function call.  The code is
1530    moved to the start of the function so the incoming values are
1531    saved.  */
1532
1533 static rtx
1534 expand_builtin_apply_args (void)
1535 {
1536   /* Don't do __builtin_apply_args more than once in a function.
1537      Save the result of the first call and reuse it.  */
1538   if (apply_args_value != 0)
1539     return apply_args_value;
1540   {
1541     /* When this function is called, it means that registers must be
1542        saved on entry to this function.  So we migrate the
1543        call to the first insn of this function.  */
1544     rtx temp;
1545     rtx seq;
1546
1547     start_sequence ();
1548     temp = expand_builtin_apply_args_1 ();
1549     seq = get_insns ();
1550     end_sequence ();
1551
1552     apply_args_value = temp;
1553
1554     /* Put the insns after the NOTE that starts the function.
1555        If this is inside a start_sequence, make the outer-level insn
1556        chain current, so the code is placed at the start of the
1557        function.  If internal_arg_pointer is a non-virtual pseudo,
1558        it needs to be placed after the function that initializes
1559        that pseudo.  */
1560     push_topmost_sequence ();
1561     if (REG_P (crtl->args.internal_arg_pointer)
1562         && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1563       emit_insn_before (seq, parm_birth_insn);
1564     else
1565       emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1566     pop_topmost_sequence ();
1567     return temp;
1568   }
1569 }
1570
1571 /* Perform an untyped call and save the state required to perform an
1572    untyped return of whatever value was returned by the given function.  */
1573
1574 static rtx
1575 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1576 {
1577   int size, align, regno;
1578   enum machine_mode mode;
1579   rtx incoming_args, result, reg, dest, src, call_insn;
1580   rtx old_stack_level = 0;
1581   rtx call_fusage = 0;
1582   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1583
1584   arguments = convert_memory_address (Pmode, arguments);
1585
1586   /* Create a block where the return registers can be saved.  */
1587   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1588
1589   /* Fetch the arg pointer from the ARGUMENTS block.  */
1590   incoming_args = gen_reg_rtx (Pmode);
1591   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1592 #ifndef STACK_GROWS_DOWNWARD
1593   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1594                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1595 #endif
1596
1597   /* Push a new argument block and copy the arguments.  Do not allow
1598      the (potential) memcpy call below to interfere with our stack
1599      manipulations.  */
1600   do_pending_stack_adjust ();
1601   NO_DEFER_POP;
1602
1603   /* Save the stack with nonlocal if available.  */
1604 #ifdef HAVE_save_stack_nonlocal
1605   if (HAVE_save_stack_nonlocal)
1606     emit_stack_save (SAVE_NONLOCAL, &old_stack_level);
1607   else
1608 #endif
1609     emit_stack_save (SAVE_BLOCK, &old_stack_level);
1610
1611   /* Allocate a block of memory onto the stack and copy the memory
1612      arguments to the outgoing arguments address.  We can pass TRUE
1613      as the 4th argument because we just saved the stack pointer
1614      and will restore it right after the call.  */
1615   allocate_dynamic_stack_space (argsize, 0, BIGGEST_ALIGNMENT, true);
1616
1617   /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1618      may have already set current_function_calls_alloca to true.
1619      current_function_calls_alloca won't be set if argsize is zero,
1620      so we have to guarantee need_drap is true here.  */
1621   if (SUPPORTS_STACK_ALIGNMENT)
1622     crtl->need_drap = true;
1623
1624   dest = virtual_outgoing_args_rtx;
1625 #ifndef STACK_GROWS_DOWNWARD
1626   if (CONST_INT_P (argsize))
1627     dest = plus_constant (dest, -INTVAL (argsize));
1628   else
1629     dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1630 #endif
1631   dest = gen_rtx_MEM (BLKmode, dest);
1632   set_mem_align (dest, PARM_BOUNDARY);
1633   src = gen_rtx_MEM (BLKmode, incoming_args);
1634   set_mem_align (src, PARM_BOUNDARY);
1635   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1636
1637   /* Refer to the argument block.  */
1638   apply_args_size ();
1639   arguments = gen_rtx_MEM (BLKmode, arguments);
1640   set_mem_align (arguments, PARM_BOUNDARY);
1641
1642   /* Walk past the arg-pointer and structure value address.  */
1643   size = GET_MODE_SIZE (Pmode);
1644   if (struct_value)
1645     size += GET_MODE_SIZE (Pmode);
1646
1647   /* Restore each of the registers previously saved.  Make USE insns
1648      for each of these registers for use in making the call.  */
1649   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1650     if ((mode = apply_args_mode[regno]) != VOIDmode)
1651       {
1652         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1653         if (size % align != 0)
1654           size = CEIL (size, align) * align;
1655         reg = gen_rtx_REG (mode, regno);
1656         emit_move_insn (reg, adjust_address (arguments, mode, size));
1657         use_reg (&call_fusage, reg);
1658         size += GET_MODE_SIZE (mode);
1659       }
1660
1661   /* Restore the structure value address unless this is passed as an
1662      "invisible" first argument.  */
1663   size = GET_MODE_SIZE (Pmode);
1664   if (struct_value)
1665     {
1666       rtx value = gen_reg_rtx (Pmode);
1667       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1668       emit_move_insn (struct_value, value);
1669       if (REG_P (struct_value))
1670         use_reg (&call_fusage, struct_value);
1671       size += GET_MODE_SIZE (Pmode);
1672     }
1673
1674   /* All arguments and registers used for the call are set up by now!  */
1675   function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1676
1677   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1678      and we don't want to load it into a register as an optimization,
1679      because prepare_call_address already did it if it should be done.  */
1680   if (GET_CODE (function) != SYMBOL_REF)
1681     function = memory_address (FUNCTION_MODE, function);
1682
1683   /* Generate the actual call instruction and save the return value.  */
1684 #ifdef HAVE_untyped_call
1685   if (HAVE_untyped_call)
1686     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1687                                       result, result_vector (1, result)));
1688   else
1689 #endif
1690 #ifdef HAVE_call_value
1691   if (HAVE_call_value)
1692     {
1693       rtx valreg = 0;
1694
1695       /* Locate the unique return register.  It is not possible to
1696          express a call that sets more than one return register using
1697          call_value; use untyped_call for that.  In fact, untyped_call
1698          only needs to save the return registers in the given block.  */
1699       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1700         if ((mode = apply_result_mode[regno]) != VOIDmode)
1701           {
1702             gcc_assert (!valreg); /* HAVE_untyped_call required.  */
1703
1704             valreg = gen_rtx_REG (mode, regno);
1705           }
1706
1707       emit_call_insn (GEN_CALL_VALUE (valreg,
1708                                       gen_rtx_MEM (FUNCTION_MODE, function),
1709                                       const0_rtx, NULL_RTX, const0_rtx));
1710
1711       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1712     }
1713   else
1714 #endif
1715     gcc_unreachable ();
1716
1717   /* Find the CALL insn we just emitted, and attach the register usage
1718      information.  */
1719   call_insn = last_call_insn ();
1720   add_function_usage_to (call_insn, call_fusage);
1721
1722   /* Restore the stack.  */
1723 #ifdef HAVE_save_stack_nonlocal
1724   if (HAVE_save_stack_nonlocal)
1725     emit_stack_restore (SAVE_NONLOCAL, old_stack_level);
1726   else
1727 #endif
1728     emit_stack_restore (SAVE_BLOCK, old_stack_level);
1729   fixup_args_size_notes (call_insn, get_last_insn(), 0);
1730
1731   OK_DEFER_POP;
1732
1733   /* Return the address of the result block.  */
1734   result = copy_addr_to_reg (XEXP (result, 0));
1735   return convert_memory_address (ptr_mode, result);
1736 }
1737
1738 /* Perform an untyped return.  */
1739
1740 static void
1741 expand_builtin_return (rtx result)
1742 {
1743   int size, align, regno;
1744   enum machine_mode mode;
1745   rtx reg;
1746   rtx call_fusage = 0;
1747
1748   result = convert_memory_address (Pmode, result);
1749
1750   apply_result_size ();
1751   result = gen_rtx_MEM (BLKmode, result);
1752
1753 #ifdef HAVE_untyped_return
1754   if (HAVE_untyped_return)
1755     {
1756       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1757       emit_barrier ();
1758       return;
1759     }
1760 #endif
1761
1762   /* Restore the return value and note that each value is used.  */
1763   size = 0;
1764   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1765     if ((mode = apply_result_mode[regno]) != VOIDmode)
1766       {
1767         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1768         if (size % align != 0)
1769           size = CEIL (size, align) * align;
1770         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1771         emit_move_insn (reg, adjust_address (result, mode, size));
1772
1773         push_to_sequence (call_fusage);
1774         emit_use (reg);
1775         call_fusage = get_insns ();
1776         end_sequence ();
1777         size += GET_MODE_SIZE (mode);
1778       }
1779
1780   /* Put the USE insns before the return.  */
1781   emit_insn (call_fusage);
1782
1783   /* Return whatever values was restored by jumping directly to the end
1784      of the function.  */
1785   expand_naked_return ();
1786 }
1787
1788 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1789
1790 static enum type_class
1791 type_to_class (tree type)
1792 {
1793   switch (TREE_CODE (type))
1794     {
1795     case VOID_TYPE:        return void_type_class;
1796     case INTEGER_TYPE:     return integer_type_class;
1797     case ENUMERAL_TYPE:    return enumeral_type_class;
1798     case BOOLEAN_TYPE:     return boolean_type_class;
1799     case POINTER_TYPE:     return pointer_type_class;
1800     case REFERENCE_TYPE:   return reference_type_class;
1801     case OFFSET_TYPE:      return offset_type_class;
1802     case REAL_TYPE:        return real_type_class;
1803     case COMPLEX_TYPE:     return complex_type_class;
1804     case FUNCTION_TYPE:    return function_type_class;
1805     case METHOD_TYPE:      return method_type_class;
1806     case RECORD_TYPE:      return record_type_class;
1807     case UNION_TYPE:
1808     case QUAL_UNION_TYPE:  return union_type_class;
1809     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1810                                    ? string_type_class : array_type_class);
1811     case LANG_TYPE:        return lang_type_class;
1812     default:               return no_type_class;
1813     }
1814 }
1815
1816 /* Expand a call EXP to __builtin_classify_type.  */
1817
1818 static rtx
1819 expand_builtin_classify_type (tree exp)
1820 {
1821   if (call_expr_nargs (exp))
1822     return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1823   return GEN_INT (no_type_class);
1824 }
1825
1826 /* This helper macro, meant to be used in mathfn_built_in below,
1827    determines which among a set of three builtin math functions is
1828    appropriate for a given type mode.  The `F' and `L' cases are
1829    automatically generated from the `double' case.  */
1830 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1831   case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1832   fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1833   fcodel = BUILT_IN_MATHFN##L ; break;
1834 /* Similar to above, but appends _R after any F/L suffix.  */
1835 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1836   case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1837   fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1838   fcodel = BUILT_IN_MATHFN##L_R ; break;
1839
1840 /* Return mathematic function equivalent to FN but operating directly on TYPE,
1841    if available.  If IMPLICIT is true use the implicit builtin declaration,
1842    otherwise use the explicit declaration.  If we can't do the conversion,
1843    return zero.  */
1844
1845 static tree
1846 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit_p)
1847 {
1848   enum built_in_function fcode, fcodef, fcodel, fcode2;
1849
1850   switch (fn)
1851     {
1852       CASE_MATHFN (BUILT_IN_ACOS)
1853       CASE_MATHFN (BUILT_IN_ACOSH)
1854       CASE_MATHFN (BUILT_IN_ASIN)
1855       CASE_MATHFN (BUILT_IN_ASINH)
1856       CASE_MATHFN (BUILT_IN_ATAN)
1857       CASE_MATHFN (BUILT_IN_ATAN2)
1858       CASE_MATHFN (BUILT_IN_ATANH)
1859       CASE_MATHFN (BUILT_IN_CBRT)
1860       CASE_MATHFN (BUILT_IN_CEIL)
1861       CASE_MATHFN (BUILT_IN_CEXPI)
1862       CASE_MATHFN (BUILT_IN_COPYSIGN)
1863       CASE_MATHFN (BUILT_IN_COS)
1864       CASE_MATHFN (BUILT_IN_COSH)
1865       CASE_MATHFN (BUILT_IN_DREM)
1866       CASE_MATHFN (BUILT_IN_ERF)
1867       CASE_MATHFN (BUILT_IN_ERFC)
1868       CASE_MATHFN (BUILT_IN_EXP)
1869       CASE_MATHFN (BUILT_IN_EXP10)
1870       CASE_MATHFN (BUILT_IN_EXP2)
1871       CASE_MATHFN (BUILT_IN_EXPM1)
1872       CASE_MATHFN (BUILT_IN_FABS)
1873       CASE_MATHFN (BUILT_IN_FDIM)
1874       CASE_MATHFN (BUILT_IN_FLOOR)
1875       CASE_MATHFN (BUILT_IN_FMA)
1876       CASE_MATHFN (BUILT_IN_FMAX)
1877       CASE_MATHFN (BUILT_IN_FMIN)
1878       CASE_MATHFN (BUILT_IN_FMOD)
1879       CASE_MATHFN (BUILT_IN_FREXP)
1880       CASE_MATHFN (BUILT_IN_GAMMA)
1881       CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1882       CASE_MATHFN (BUILT_IN_HUGE_VAL)
1883       CASE_MATHFN (BUILT_IN_HYPOT)
1884       CASE_MATHFN (BUILT_IN_ILOGB)
1885       CASE_MATHFN (BUILT_IN_ICEIL)
1886       CASE_MATHFN (BUILT_IN_IFLOOR)
1887       CASE_MATHFN (BUILT_IN_INF)
1888       CASE_MATHFN (BUILT_IN_IRINT)
1889       CASE_MATHFN (BUILT_IN_IROUND)
1890       CASE_MATHFN (BUILT_IN_ISINF)
1891       CASE_MATHFN (BUILT_IN_J0)
1892       CASE_MATHFN (BUILT_IN_J1)
1893       CASE_MATHFN (BUILT_IN_JN)
1894       CASE_MATHFN (BUILT_IN_LCEIL)
1895       CASE_MATHFN (BUILT_IN_LDEXP)
1896       CASE_MATHFN (BUILT_IN_LFLOOR)
1897       CASE_MATHFN (BUILT_IN_LGAMMA)
1898       CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1899       CASE_MATHFN (BUILT_IN_LLCEIL)
1900       CASE_MATHFN (BUILT_IN_LLFLOOR)
1901       CASE_MATHFN (BUILT_IN_LLRINT)
1902       CASE_MATHFN (BUILT_IN_LLROUND)
1903       CASE_MATHFN (BUILT_IN_LOG)
1904       CASE_MATHFN (BUILT_IN_LOG10)
1905       CASE_MATHFN (BUILT_IN_LOG1P)
1906       CASE_MATHFN (BUILT_IN_LOG2)
1907       CASE_MATHFN (BUILT_IN_LOGB)
1908       CASE_MATHFN (BUILT_IN_LRINT)
1909       CASE_MATHFN (BUILT_IN_LROUND)
1910       CASE_MATHFN (BUILT_IN_MODF)
1911       CASE_MATHFN (BUILT_IN_NAN)
1912       CASE_MATHFN (BUILT_IN_NANS)
1913       CASE_MATHFN (BUILT_IN_NEARBYINT)
1914       CASE_MATHFN (BUILT_IN_NEXTAFTER)
1915       CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1916       CASE_MATHFN (BUILT_IN_POW)
1917       CASE_MATHFN (BUILT_IN_POWI)
1918       CASE_MATHFN (BUILT_IN_POW10)
1919       CASE_MATHFN (BUILT_IN_REMAINDER)
1920       CASE_MATHFN (BUILT_IN_REMQUO)
1921       CASE_MATHFN (BUILT_IN_RINT)
1922       CASE_MATHFN (BUILT_IN_ROUND)
1923       CASE_MATHFN (BUILT_IN_SCALB)
1924       CASE_MATHFN (BUILT_IN_SCALBLN)
1925       CASE_MATHFN (BUILT_IN_SCALBN)
1926       CASE_MATHFN (BUILT_IN_SIGNBIT)
1927       CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1928       CASE_MATHFN (BUILT_IN_SIN)
1929       CASE_MATHFN (BUILT_IN_SINCOS)
1930       CASE_MATHFN (BUILT_IN_SINH)
1931       CASE_MATHFN (BUILT_IN_SQRT)
1932       CASE_MATHFN (BUILT_IN_TAN)
1933       CASE_MATHFN (BUILT_IN_TANH)
1934       CASE_MATHFN (BUILT_IN_TGAMMA)
1935       CASE_MATHFN (BUILT_IN_TRUNC)
1936       CASE_MATHFN (BUILT_IN_Y0)
1937       CASE_MATHFN (BUILT_IN_Y1)
1938       CASE_MATHFN (BUILT_IN_YN)
1939
1940       default:
1941         return NULL_TREE;
1942       }
1943
1944   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1945     fcode2 = fcode;
1946   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1947     fcode2 = fcodef;
1948   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1949     fcode2 = fcodel;
1950   else
1951     return NULL_TREE;
1952
1953   if (implicit_p && !builtin_decl_implicit_p (fcode2))
1954     return NULL_TREE;
1955
1956   return builtin_decl_explicit (fcode2);
1957 }
1958
1959 /* Like mathfn_built_in_1(), but always use the implicit array.  */
1960
1961 tree
1962 mathfn_built_in (tree type, enum built_in_function fn)
1963 {
1964   return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1965 }
1966
1967 /* If errno must be maintained, expand the RTL to check if the result,
1968    TARGET, of a built-in function call, EXP, is NaN, and if so set
1969    errno to EDOM.  */
1970
1971 static void
1972 expand_errno_check (tree exp, rtx target)
1973 {
1974   rtx lab = gen_label_rtx ();
1975
1976   /* Test the result; if it is NaN, set errno=EDOM because
1977      the argument was not in the domain.  */
1978   do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1979                            NULL_RTX, NULL_RTX, lab,
1980                            /* The jump is very likely.  */
1981                            REG_BR_PROB_BASE - (REG_BR_PROB_BASE / 2000 - 1));
1982
1983 #ifdef TARGET_EDOM
1984   /* If this built-in doesn't throw an exception, set errno directly.  */
1985   if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1986     {
1987 #ifdef GEN_ERRNO_RTX
1988       rtx errno_rtx = GEN_ERRNO_RTX;
1989 #else
1990       rtx errno_rtx
1991           = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1992 #endif
1993       emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1994       emit_label (lab);
1995       return;
1996     }
1997 #endif
1998
1999   /* Make sure the library call isn't expanded as a tail call.  */
2000   CALL_EXPR_TAILCALL (exp) = 0;
2001
2002   /* We can't set errno=EDOM directly; let the library call do it.
2003      Pop the arguments right away in case the call gets deleted.  */
2004   NO_DEFER_POP;
2005   expand_call (exp, target, 0);
2006   OK_DEFER_POP;
2007   emit_label (lab);
2008 }
2009
2010 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
2011    Return NULL_RTX if a normal call should be emitted rather than expanding
2012    the function in-line.  EXP is the expression that is a call to the builtin
2013    function; if convenient, the result should be placed in TARGET.
2014    SUBTARGET may be used as the target for computing one of EXP's operands.  */
2015
2016 static rtx
2017 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
2018 {
2019   optab builtin_optab;
2020   rtx op0, insns;
2021   tree fndecl = get_callee_fndecl (exp);
2022   enum machine_mode mode;
2023   bool errno_set = false;
2024   tree arg;
2025
2026   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2027     return NULL_RTX;
2028
2029   arg = CALL_EXPR_ARG (exp, 0);
2030
2031   switch (DECL_FUNCTION_CODE (fndecl))
2032     {
2033     CASE_FLT_FN (BUILT_IN_SQRT):
2034       errno_set = ! tree_expr_nonnegative_p (arg);
2035       builtin_optab = sqrt_optab;
2036       break;
2037     CASE_FLT_FN (BUILT_IN_EXP):
2038       errno_set = true; builtin_optab = exp_optab; break;
2039     CASE_FLT_FN (BUILT_IN_EXP10):
2040     CASE_FLT_FN (BUILT_IN_POW10):
2041       errno_set = true; builtin_optab = exp10_optab; break;
2042     CASE_FLT_FN (BUILT_IN_EXP2):
2043       errno_set = true; builtin_optab = exp2_optab; break;
2044     CASE_FLT_FN (BUILT_IN_EXPM1):
2045       errno_set = true; builtin_optab = expm1_optab; break;
2046     CASE_FLT_FN (BUILT_IN_LOGB):
2047       errno_set = true; builtin_optab = logb_optab; break;
2048     CASE_FLT_FN (BUILT_IN_LOG):
2049       errno_set = true; builtin_optab = log_optab; break;
2050     CASE_FLT_FN (BUILT_IN_LOG10):
2051       errno_set = true; builtin_optab = log10_optab; break;
2052     CASE_FLT_FN (BUILT_IN_LOG2):
2053       errno_set = true; builtin_optab = log2_optab; break;
2054     CASE_FLT_FN (BUILT_IN_LOG1P):
2055       errno_set = true; builtin_optab = log1p_optab; break;
2056     CASE_FLT_FN (BUILT_IN_ASIN):
2057       builtin_optab = asin_optab; break;
2058     CASE_FLT_FN (BUILT_IN_ACOS):
2059       builtin_optab = acos_optab; break;
2060     CASE_FLT_FN (BUILT_IN_TAN):
2061       builtin_optab = tan_optab; break;
2062     CASE_FLT_FN (BUILT_IN_ATAN):
2063       builtin_optab = atan_optab; break;
2064     CASE_FLT_FN (BUILT_IN_FLOOR):
2065       builtin_optab = floor_optab; break;
2066     CASE_FLT_FN (BUILT_IN_CEIL):
2067       builtin_optab = ceil_optab; break;
2068     CASE_FLT_FN (BUILT_IN_TRUNC):
2069       builtin_optab = btrunc_optab; break;
2070     CASE_FLT_FN (BUILT_IN_ROUND):
2071       builtin_optab = round_optab; break;
2072     CASE_FLT_FN (BUILT_IN_NEARBYINT):
2073       builtin_optab = nearbyint_optab;
2074       if (flag_trapping_math)
2075         break;
2076       /* Else fallthrough and expand as rint.  */
2077     CASE_FLT_FN (BUILT_IN_RINT):
2078       builtin_optab = rint_optab; break;
2079     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
2080       builtin_optab = significand_optab; break;
2081     default:
2082       gcc_unreachable ();
2083     }
2084
2085   /* Make a suitable register to place result in.  */
2086   mode = TYPE_MODE (TREE_TYPE (exp));
2087
2088   if (! flag_errno_math || ! HONOR_NANS (mode))
2089     errno_set = false;
2090
2091   /* Before working hard, check whether the instruction is available.  */
2092   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing
2093       && (!errno_set || !optimize_insn_for_size_p ()))
2094     {
2095       target = gen_reg_rtx (mode);
2096
2097       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2098          need to expand the argument again.  This way, we will not perform
2099          side-effects more the once.  */
2100       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2101
2102       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2103
2104       start_sequence ();
2105
2106       /* Compute into TARGET.
2107          Set TARGET to wherever the result comes back.  */
2108       target = expand_unop (mode, builtin_optab, op0, target, 0);
2109
2110       if (target != 0)
2111         {
2112           if (errno_set)
2113             expand_errno_check (exp, target);
2114
2115           /* Output the entire sequence.  */
2116           insns = get_insns ();
2117           end_sequence ();
2118           emit_insn (insns);
2119           return target;
2120         }
2121
2122       /* If we were unable to expand via the builtin, stop the sequence
2123          (without outputting the insns) and call to the library function
2124          with the stabilized argument list.  */
2125       end_sequence ();
2126     }
2127
2128   return expand_call (exp, target, target == const0_rtx);
2129 }
2130
2131 /* Expand a call to the builtin binary math functions (pow and atan2).
2132    Return NULL_RTX if a normal call should be emitted rather than expanding the
2133    function in-line.  EXP is the expression that is a call to the builtin
2134    function; if convenient, the result should be placed in TARGET.
2135    SUBTARGET may be used as the target for computing one of EXP's
2136    operands.  */
2137
2138 static rtx
2139 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2140 {
2141   optab builtin_optab;
2142   rtx op0, op1, insns;
2143   int op1_type = REAL_TYPE;
2144   tree fndecl = get_callee_fndecl (exp);
2145   tree arg0, arg1;
2146   enum machine_mode mode;
2147   bool errno_set = true;
2148
2149   switch (DECL_FUNCTION_CODE (fndecl))
2150     {
2151     CASE_FLT_FN (BUILT_IN_SCALBN):
2152     CASE_FLT_FN (BUILT_IN_SCALBLN):
2153     CASE_FLT_FN (BUILT_IN_LDEXP):
2154       op1_type = INTEGER_TYPE;
2155     default:
2156       break;
2157     }
2158
2159   if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2160     return NULL_RTX;
2161
2162   arg0 = CALL_EXPR_ARG (exp, 0);
2163   arg1 = CALL_EXPR_ARG (exp, 1);
2164
2165   switch (DECL_FUNCTION_CODE (fndecl))
2166     {
2167     CASE_FLT_FN (BUILT_IN_POW):
2168       builtin_optab = pow_optab; break;
2169     CASE_FLT_FN (BUILT_IN_ATAN2):
2170       builtin_optab = atan2_optab; break;
2171     CASE_FLT_FN (BUILT_IN_SCALB):
2172       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2173         return 0;
2174       builtin_optab = scalb_optab; break;
2175     CASE_FLT_FN (BUILT_IN_SCALBN):
2176     CASE_FLT_FN (BUILT_IN_SCALBLN):
2177       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2178         return 0;
2179     /* Fall through... */
2180     CASE_FLT_FN (BUILT_IN_LDEXP):
2181       builtin_optab = ldexp_optab; break;
2182     CASE_FLT_FN (BUILT_IN_FMOD):
2183       builtin_optab = fmod_optab; break;
2184     CASE_FLT_FN (BUILT_IN_REMAINDER):
2185     CASE_FLT_FN (BUILT_IN_DREM):
2186       builtin_optab = remainder_optab; break;
2187     default:
2188       gcc_unreachable ();
2189     }
2190
2191   /* Make a suitable register to place result in.  */
2192   mode = TYPE_MODE (TREE_TYPE (exp));
2193
2194   /* Before working hard, check whether the instruction is available.  */
2195   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2196     return NULL_RTX;
2197
2198   target = gen_reg_rtx (mode);
2199
2200   if (! flag_errno_math || ! HONOR_NANS (mode))
2201     errno_set = false;
2202
2203   if (errno_set && optimize_insn_for_size_p ())
2204     return 0;
2205
2206   /* Always stabilize the argument list.  */
2207   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2208   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2209
2210   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2211   op1 = expand_normal (arg1);
2212
2213   start_sequence ();
2214
2215   /* Compute into TARGET.
2216      Set TARGET to wherever the result comes back.  */
2217   target = expand_binop (mode, builtin_optab, op0, op1,
2218                          target, 0, OPTAB_DIRECT);
2219
2220   /* If we were unable to expand via the builtin, stop the sequence
2221      (without outputting the insns) and call to the library function
2222      with the stabilized argument list.  */
2223   if (target == 0)
2224     {
2225       end_sequence ();
2226       return expand_call (exp, target, target == const0_rtx);
2227     }
2228
2229   if (errno_set)
2230     expand_errno_check (exp, target);
2231
2232   /* Output the entire sequence.  */
2233   insns = get_insns ();
2234   end_sequence ();
2235   emit_insn (insns);
2236
2237   return target;
2238 }
2239
2240 /* Expand a call to the builtin trinary math functions (fma).
2241    Return NULL_RTX if a normal call should be emitted rather than expanding the
2242    function in-line.  EXP is the expression that is a call to the builtin
2243    function; if convenient, the result should be placed in TARGET.
2244    SUBTARGET may be used as the target for computing one of EXP's
2245    operands.  */
2246
2247 static rtx
2248 expand_builtin_mathfn_ternary (tree exp, rtx target, rtx subtarget)
2249 {
2250   optab builtin_optab;
2251   rtx op0, op1, op2, insns;
2252   tree fndecl = get_callee_fndecl (exp);
2253   tree arg0, arg1, arg2;
2254   enum machine_mode mode;
2255
2256   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2257     return NULL_RTX;
2258
2259   arg0 = CALL_EXPR_ARG (exp, 0);
2260   arg1 = CALL_EXPR_ARG (exp, 1);
2261   arg2 = CALL_EXPR_ARG (exp, 2);
2262
2263   switch (DECL_FUNCTION_CODE (fndecl))
2264     {
2265     CASE_FLT_FN (BUILT_IN_FMA):
2266       builtin_optab = fma_optab; break;
2267     default:
2268       gcc_unreachable ();
2269     }
2270
2271   /* Make a suitable register to place result in.  */
2272   mode = TYPE_MODE (TREE_TYPE (exp));
2273
2274   /* Before working hard, check whether the instruction is available.  */
2275   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2276     return NULL_RTX;
2277
2278   target = gen_reg_rtx (mode);
2279
2280   /* Always stabilize the argument list.  */
2281   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2282   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2283   CALL_EXPR_ARG (exp, 2) = arg2 = builtin_save_expr (arg2);
2284
2285   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2286   op1 = expand_normal (arg1);
2287   op2 = expand_normal (arg2);
2288
2289   start_sequence ();
2290
2291   /* Compute into TARGET.
2292      Set TARGET to wherever the result comes back.  */
2293   target = expand_ternary_op (mode, builtin_optab, op0, op1, op2,
2294                               target, 0);
2295
2296   /* If we were unable to expand via the builtin, stop the sequence
2297      (without outputting the insns) and call to the library function
2298      with the stabilized argument list.  */
2299   if (target == 0)
2300     {
2301       end_sequence ();
2302       return expand_call (exp, target, target == const0_rtx);
2303     }
2304
2305   /* Output the entire sequence.  */
2306   insns = get_insns ();
2307   end_sequence ();
2308   emit_insn (insns);
2309
2310   return target;
2311 }
2312
2313 /* Expand a call to the builtin sin and cos math functions.
2314    Return NULL_RTX if a normal call should be emitted rather than expanding the
2315    function in-line.  EXP is the expression that is a call to the builtin
2316    function; if convenient, the result should be placed in TARGET.
2317    SUBTARGET may be used as the target for computing one of EXP's
2318    operands.  */
2319
2320 static rtx
2321 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2322 {
2323   optab builtin_optab;
2324   rtx op0, insns;
2325   tree fndecl = get_callee_fndecl (exp);
2326   enum machine_mode mode;
2327   tree arg;
2328
2329   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2330     return NULL_RTX;
2331
2332   arg = CALL_EXPR_ARG (exp, 0);
2333
2334   switch (DECL_FUNCTION_CODE (fndecl))
2335     {
2336     CASE_FLT_FN (BUILT_IN_SIN):
2337     CASE_FLT_FN (BUILT_IN_COS):
2338       builtin_optab = sincos_optab; break;
2339     default:
2340       gcc_unreachable ();
2341     }
2342
2343   /* Make a suitable register to place result in.  */
2344   mode = TYPE_MODE (TREE_TYPE (exp));
2345
2346   /* Check if sincos insn is available, otherwise fallback
2347      to sin or cos insn.  */
2348   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2349     switch (DECL_FUNCTION_CODE (fndecl))
2350       {
2351       CASE_FLT_FN (BUILT_IN_SIN):
2352         builtin_optab = sin_optab; break;
2353       CASE_FLT_FN (BUILT_IN_COS):
2354         builtin_optab = cos_optab; break;
2355       default:
2356         gcc_unreachable ();
2357       }
2358
2359   /* Before working hard, check whether the instruction is available.  */
2360   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2361     {
2362       target = gen_reg_rtx (mode);
2363
2364       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2365          need to expand the argument again.  This way, we will not perform
2366          side-effects more the once.  */
2367       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2368
2369       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2370
2371       start_sequence ();
2372
2373       /* Compute into TARGET.
2374          Set TARGET to wherever the result comes back.  */
2375       if (builtin_optab == sincos_optab)
2376         {
2377           int result;
2378
2379           switch (DECL_FUNCTION_CODE (fndecl))
2380             {
2381             CASE_FLT_FN (BUILT_IN_SIN):
2382               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2383               break;
2384             CASE_FLT_FN (BUILT_IN_COS):
2385               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2386               break;
2387             default:
2388               gcc_unreachable ();
2389             }
2390           gcc_assert (result);
2391         }
2392       else
2393         {
2394           target = expand_unop (mode, builtin_optab, op0, target, 0);
2395         }
2396
2397       if (target != 0)
2398         {
2399           /* Output the entire sequence.  */
2400           insns = get_insns ();
2401           end_sequence ();
2402           emit_insn (insns);
2403           return target;
2404         }
2405
2406       /* If we were unable to expand via the builtin, stop the sequence
2407          (without outputting the insns) and call to the library function
2408          with the stabilized argument list.  */
2409       end_sequence ();
2410     }
2411
2412   target = expand_call (exp, target, target == const0_rtx);
2413
2414   return target;
2415 }
2416
2417 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2418    return an RTL instruction code that implements the functionality.
2419    If that isn't possible or available return CODE_FOR_nothing.  */
2420
2421 static enum insn_code
2422 interclass_mathfn_icode (tree arg, tree fndecl)
2423 {
2424   bool errno_set = false;
2425   optab builtin_optab = 0;
2426   enum machine_mode mode;
2427
2428   switch (DECL_FUNCTION_CODE (fndecl))
2429     {
2430     CASE_FLT_FN (BUILT_IN_ILOGB):
2431       errno_set = true; builtin_optab = ilogb_optab; break;
2432     CASE_FLT_FN (BUILT_IN_ISINF):
2433       builtin_optab = isinf_optab; break;
2434     case BUILT_IN_ISNORMAL:
2435     case BUILT_IN_ISFINITE:
2436     CASE_FLT_FN (BUILT_IN_FINITE):
2437     case BUILT_IN_FINITED32:
2438     case BUILT_IN_FINITED64:
2439     case BUILT_IN_FINITED128:
2440     case BUILT_IN_ISINFD32:
2441     case BUILT_IN_ISINFD64:
2442     case BUILT_IN_ISINFD128:
2443       /* These builtins have no optabs (yet).  */
2444       break;
2445     default:
2446       gcc_unreachable ();
2447     }
2448
2449   /* There's no easy way to detect the case we need to set EDOM.  */
2450   if (flag_errno_math && errno_set)
2451     return CODE_FOR_nothing;
2452
2453   /* Optab mode depends on the mode of the input argument.  */
2454   mode = TYPE_MODE (TREE_TYPE (arg));
2455
2456   if (builtin_optab)
2457     return optab_handler (builtin_optab, mode);
2458   return CODE_FOR_nothing;
2459 }
2460
2461 /* Expand a call to one of the builtin math functions that operate on
2462    floating point argument and output an integer result (ilogb, isinf,
2463    isnan, etc).
2464    Return 0 if a normal call should be emitted rather than expanding the
2465    function in-line.  EXP is the expression that is a call to the builtin
2466    function; if convenient, the result should be placed in TARGET.  */
2467
2468 static rtx
2469 expand_builtin_interclass_mathfn (tree exp, rtx target)
2470 {
2471   enum insn_code icode = CODE_FOR_nothing;
2472   rtx op0;
2473   tree fndecl = get_callee_fndecl (exp);
2474   enum machine_mode mode;
2475   tree arg;
2476
2477   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2478     return NULL_RTX;
2479
2480   arg = CALL_EXPR_ARG (exp, 0);
2481   icode = interclass_mathfn_icode (arg, fndecl);
2482   mode = TYPE_MODE (TREE_TYPE (arg));
2483
2484   if (icode != CODE_FOR_nothing)
2485     {
2486       struct expand_operand ops[1];
2487       rtx last = get_last_insn ();
2488       tree orig_arg = arg;
2489
2490       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2491          need to expand the argument again.  This way, we will not perform
2492          side-effects more the once.  */
2493       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2494
2495       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2496
2497       if (mode != GET_MODE (op0))
2498         op0 = convert_to_mode (mode, op0, 0);
2499
2500       create_output_operand (&ops[0], target, TYPE_MODE (TREE_TYPE (exp)));
2501       if (maybe_legitimize_operands (icode, 0, 1, ops)
2502           && maybe_emit_unop_insn (icode, ops[0].value, op0, UNKNOWN))
2503         return ops[0].value;
2504
2505       delete_insns_since (last);
2506       CALL_EXPR_ARG (exp, 0) = orig_arg;
2507     }
2508
2509   return NULL_RTX;
2510 }
2511
2512 /* Expand a call to the builtin sincos math function.
2513    Return NULL_RTX if a normal call should be emitted rather than expanding the
2514    function in-line.  EXP is the expression that is a call to the builtin
2515    function.  */
2516
2517 static rtx
2518 expand_builtin_sincos (tree exp)
2519 {
2520   rtx op0, op1, op2, target1, target2;
2521   enum machine_mode mode;
2522   tree arg, sinp, cosp;
2523   int result;
2524   location_t loc = EXPR_LOCATION (exp);
2525   tree alias_type, alias_off;
2526
2527   if (!validate_arglist (exp, REAL_TYPE,
2528                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2529     return NULL_RTX;
2530
2531   arg = CALL_EXPR_ARG (exp, 0);
2532   sinp = CALL_EXPR_ARG (exp, 1);
2533   cosp = CALL_EXPR_ARG (exp, 2);
2534
2535   /* Make a suitable register to place result in.  */
2536   mode = TYPE_MODE (TREE_TYPE (arg));
2537
2538   /* Check if sincos insn is available, otherwise emit the call.  */
2539   if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2540     return NULL_RTX;
2541
2542   target1 = gen_reg_rtx (mode);
2543   target2 = gen_reg_rtx (mode);
2544
2545   op0 = expand_normal (arg);
2546   alias_type = build_pointer_type_for_mode (TREE_TYPE (arg), ptr_mode, true);
2547   alias_off = build_int_cst (alias_type, 0);
2548   op1 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2549                                         sinp, alias_off));
2550   op2 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2551                                         cosp, alias_off));
2552
2553   /* Compute into target1 and target2.
2554      Set TARGET to wherever the result comes back.  */
2555   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2556   gcc_assert (result);
2557
2558   /* Move target1 and target2 to the memory locations indicated
2559      by op1 and op2.  */
2560   emit_move_insn (op1, target1);
2561   emit_move_insn (op2, target2);
2562
2563   return const0_rtx;
2564 }
2565
2566 /* Expand a call to the internal cexpi builtin to the sincos math function.
2567    EXP is the expression that is a call to the builtin function; if convenient,
2568    the result should be placed in TARGET.  */
2569
2570 static rtx
2571 expand_builtin_cexpi (tree exp, rtx target)
2572 {
2573   tree fndecl = get_callee_fndecl (exp);
2574   tree arg, type;
2575   enum machine_mode mode;
2576   rtx op0, op1, op2;
2577   location_t loc = EXPR_LOCATION (exp);
2578
2579   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2580     return NULL_RTX;
2581
2582   arg = CALL_EXPR_ARG (exp, 0);
2583   type = TREE_TYPE (arg);
2584   mode = TYPE_MODE (TREE_TYPE (arg));
2585
2586   /* Try expanding via a sincos optab, fall back to emitting a libcall
2587      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2588      is only generated from sincos, cexp or if we have either of them.  */
2589   if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2590     {
2591       op1 = gen_reg_rtx (mode);
2592       op2 = gen_reg_rtx (mode);
2593
2594       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2595
2596       /* Compute into op1 and op2.  */
2597       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2598     }
2599   else if (TARGET_HAS_SINCOS)
2600     {
2601       tree call, fn = NULL_TREE;
2602       tree top1, top2;
2603       rtx op1a, op2a;
2604
2605       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2606         fn = builtin_decl_explicit (BUILT_IN_SINCOSF);
2607       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2608         fn = builtin_decl_explicit (BUILT_IN_SINCOS);
2609       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2610         fn = builtin_decl_explicit (BUILT_IN_SINCOSL);
2611       else
2612         gcc_unreachable ();
2613
2614       op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2615       op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2616       op1a = copy_addr_to_reg (XEXP (op1, 0));
2617       op2a = copy_addr_to_reg (XEXP (op2, 0));
2618       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2619       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2620
2621       /* Make sure not to fold the sincos call again.  */
2622       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2623       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2624                                       call, 3, arg, top1, top2));
2625     }
2626   else
2627     {
2628       tree call, fn = NULL_TREE, narg;
2629       tree ctype = build_complex_type (type);
2630
2631       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2632         fn = builtin_decl_explicit (BUILT_IN_CEXPF);
2633       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2634         fn = builtin_decl_explicit (BUILT_IN_CEXP);
2635       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2636         fn = builtin_decl_explicit (BUILT_IN_CEXPL);
2637       else
2638         gcc_unreachable ();
2639
2640       /* If we don't have a decl for cexp create one.  This is the
2641          friendliest fallback if the user calls __builtin_cexpi
2642          without full target C99 function support.  */
2643       if (fn == NULL_TREE)
2644         {
2645           tree fntype;
2646           const char *name = NULL;
2647
2648           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2649             name = "cexpf";
2650           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2651             name = "cexp";
2652           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2653             name = "cexpl";
2654
2655           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2656           fn = build_fn_decl (name, fntype);
2657         }
2658
2659       narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2660                           build_real (type, dconst0), arg);
2661
2662       /* Make sure not to fold the cexp call again.  */
2663       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2664       return expand_expr (build_call_nary (ctype, call, 1, narg),
2665                           target, VOIDmode, EXPAND_NORMAL);
2666     }
2667
2668   /* Now build the proper return type.  */
2669   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2670                               make_tree (TREE_TYPE (arg), op2),
2671                               make_tree (TREE_TYPE (arg), op1)),
2672                       target, VOIDmode, EXPAND_NORMAL);
2673 }
2674
2675 /* Conveniently construct a function call expression.  FNDECL names the
2676    function to be called, N is the number of arguments, and the "..."
2677    parameters are the argument expressions.  Unlike build_call_exr
2678    this doesn't fold the call, hence it will always return a CALL_EXPR.  */
2679
2680 static tree
2681 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2682 {
2683   va_list ap;
2684   tree fntype = TREE_TYPE (fndecl);
2685   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2686
2687   va_start (ap, n);
2688   fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2689   va_end (ap);
2690   SET_EXPR_LOCATION (fn, loc);
2691   return fn;
2692 }
2693
2694 /* Expand a call to one of the builtin rounding functions gcc defines
2695    as an extension (lfloor and lceil).  As these are gcc extensions we
2696    do not need to worry about setting errno to EDOM.
2697    If expanding via optab fails, lower expression to (int)(floor(x)).
2698    EXP is the expression that is a call to the builtin function;
2699    if convenient, the result should be placed in TARGET.  */
2700
2701 static rtx
2702 expand_builtin_int_roundingfn (tree exp, rtx target)
2703 {
2704   convert_optab builtin_optab;
2705   rtx op0, insns, tmp;
2706   tree fndecl = get_callee_fndecl (exp);
2707   enum built_in_function fallback_fn;
2708   tree fallback_fndecl;
2709   enum machine_mode mode;
2710   tree arg;
2711
2712   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2713     gcc_unreachable ();
2714
2715   arg = CALL_EXPR_ARG (exp, 0);
2716
2717   switch (DECL_FUNCTION_CODE (fndecl))
2718     {
2719     CASE_FLT_FN (BUILT_IN_ICEIL):
2720     CASE_FLT_FN (BUILT_IN_LCEIL):
2721     CASE_FLT_FN (BUILT_IN_LLCEIL):
2722       builtin_optab = lceil_optab;
2723       fallback_fn = BUILT_IN_CEIL;
2724       break;
2725
2726     CASE_FLT_FN (BUILT_IN_IFLOOR):
2727     CASE_FLT_FN (BUILT_IN_LFLOOR):
2728     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2729       builtin_optab = lfloor_optab;
2730       fallback_fn = BUILT_IN_FLOOR;
2731       break;
2732
2733     default:
2734       gcc_unreachable ();
2735     }
2736
2737   /* Make a suitable register to place result in.  */
2738   mode = TYPE_MODE (TREE_TYPE (exp));
2739
2740   target = gen_reg_rtx (mode);
2741
2742   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2743      need to expand the argument again.  This way, we will not perform
2744      side-effects more the once.  */
2745   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2746
2747   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2748
2749   start_sequence ();
2750
2751   /* Compute into TARGET.  */
2752   if (expand_sfix_optab (target, op0, builtin_optab))
2753     {
2754       /* Output the entire sequence.  */
2755       insns = get_insns ();
2756       end_sequence ();
2757       emit_insn (insns);
2758       return target;
2759     }
2760
2761   /* If we were unable to expand via the builtin, stop the sequence
2762      (without outputting the insns).  */
2763   end_sequence ();
2764
2765   /* Fall back to floating point rounding optab.  */
2766   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2767
2768   /* For non-C99 targets we may end up without a fallback fndecl here
2769      if the user called __builtin_lfloor directly.  In this case emit
2770      a call to the floor/ceil variants nevertheless.  This should result
2771      in the best user experience for not full C99 targets.  */
2772   if (fallback_fndecl == NULL_TREE)
2773     {
2774       tree fntype;
2775       const char *name = NULL;
2776
2777       switch (DECL_FUNCTION_CODE (fndecl))
2778         {
2779         case BUILT_IN_ICEIL:
2780         case BUILT_IN_LCEIL:
2781         case BUILT_IN_LLCEIL:
2782           name = "ceil";
2783           break;
2784         case BUILT_IN_ICEILF:
2785         case BUILT_IN_LCEILF:
2786         case BUILT_IN_LLCEILF:
2787           name = "ceilf";
2788           break;
2789         case BUILT_IN_ICEILL:
2790         case BUILT_IN_LCEILL:
2791         case BUILT_IN_LLCEILL:
2792           name = "ceill";
2793           break;
2794         case BUILT_IN_IFLOOR:
2795         case BUILT_IN_LFLOOR:
2796         case BUILT_IN_LLFLOOR:
2797           name = "floor";
2798           break;
2799         case BUILT_IN_IFLOORF:
2800         case BUILT_IN_LFLOORF:
2801         case BUILT_IN_LLFLOORF:
2802           name = "floorf";
2803           break;
2804         case BUILT_IN_IFLOORL:
2805         case BUILT_IN_LFLOORL:
2806         case BUILT_IN_LLFLOORL:
2807           name = "floorl";
2808           break;
2809         default:
2810           gcc_unreachable ();
2811         }
2812
2813       fntype = build_function_type_list (TREE_TYPE (arg),
2814                                          TREE_TYPE (arg), NULL_TREE);
2815       fallback_fndecl = build_fn_decl (name, fntype);
2816     }
2817
2818   exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2819
2820   tmp = expand_normal (exp);
2821
2822   /* Truncate the result of floating point optab to integer
2823      via expand_fix ().  */
2824   target = gen_reg_rtx (mode);
2825   expand_fix (target, tmp, 0);
2826
2827   return target;
2828 }
2829
2830 /* Expand a call to one of the builtin math functions doing integer
2831    conversion (lrint).
2832    Return 0 if a normal call should be emitted rather than expanding the
2833    function in-line.  EXP is the expression that is a call to the builtin
2834    function; if convenient, the result should be placed in TARGET.  */
2835
2836 static rtx
2837 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2838 {
2839   convert_optab builtin_optab;
2840   rtx op0, insns;
2841   tree fndecl = get_callee_fndecl (exp);
2842   tree arg;
2843   enum machine_mode mode;
2844   enum built_in_function fallback_fn = BUILT_IN_NONE;
2845
2846   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2847      gcc_unreachable ();
2848
2849   arg = CALL_EXPR_ARG (exp, 0);
2850
2851   switch (DECL_FUNCTION_CODE (fndecl))
2852     {
2853     CASE_FLT_FN (BUILT_IN_IRINT):
2854       fallback_fn = BUILT_IN_LRINT;
2855       /* FALLTHRU */
2856     CASE_FLT_FN (BUILT_IN_LRINT):
2857     CASE_FLT_FN (BUILT_IN_LLRINT):
2858       builtin_optab = lrint_optab;
2859       break;
2860
2861     CASE_FLT_FN (BUILT_IN_IROUND):
2862       fallback_fn = BUILT_IN_LROUND;
2863       /* FALLTHRU */
2864     CASE_FLT_FN (BUILT_IN_LROUND):
2865     CASE_FLT_FN (BUILT_IN_LLROUND):
2866       builtin_optab = lround_optab;
2867       break;
2868
2869     default:
2870       gcc_unreachable ();
2871     }
2872
2873   /* There's no easy way to detect the case we need to set EDOM.  */
2874   if (flag_errno_math && fallback_fn == BUILT_IN_NONE)
2875     return NULL_RTX;
2876
2877   /* Make a suitable register to place result in.  */
2878   mode = TYPE_MODE (TREE_TYPE (exp));
2879
2880   /* There's no easy way to detect the case we need to set EDOM.  */
2881   if (!flag_errno_math)
2882     {
2883       target = gen_reg_rtx (mode);
2884
2885       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2886          need to expand the argument again.  This way, we will not perform
2887          side-effects more the once.  */
2888       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2889
2890       op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2891
2892       start_sequence ();
2893
2894       if (expand_sfix_optab (target, op0, builtin_optab))
2895         {
2896           /* Output the entire sequence.  */
2897           insns = get_insns ();
2898           end_sequence ();
2899           emit_insn (insns);
2900           return target;
2901         }
2902
2903       /* If we were unable to expand via the builtin, stop the sequence
2904          (without outputting the insns) and call to the library function
2905          with the stabilized argument list.  */
2906       end_sequence ();
2907     }
2908
2909   if (fallback_fn != BUILT_IN_NONE)
2910     {
2911       /* Fall back to rounding to long int.  Use implicit_p 0 - for non-C99
2912          targets, (int) round (x) should never be transformed into
2913          BUILT_IN_IROUND and if __builtin_iround is called directly, emit
2914          a call to lround in the hope that the target provides at least some
2915          C99 functions.  This should result in the best user experience for
2916          not full C99 targets.  */
2917       tree fallback_fndecl = mathfn_built_in_1 (TREE_TYPE (arg),
2918                                                 fallback_fn, 0);
2919
2920       exp = build_call_nofold_loc (EXPR_LOCATION (exp),
2921                                    fallback_fndecl, 1, arg);
2922
2923       target = expand_call (exp, NULL_RTX, target == const0_rtx);
2924       return convert_to_mode (mode, target, 0);
2925     }
2926
2927   target = expand_call (exp, target, target == const0_rtx);
2928
2929   return target;
2930 }
2931
2932 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
2933    a normal call should be emitted rather than expanding the function
2934    in-line.  EXP is the expression that is a call to the builtin
2935    function; if convenient, the result should be placed in TARGET.  */
2936
2937 static rtx
2938 expand_builtin_powi (tree exp, rtx target)
2939 {
2940   tree arg0, arg1;
2941   rtx op0, op1;
2942   enum machine_mode mode;
2943   enum machine_mode mode2;
2944
2945   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
2946     return NULL_RTX;
2947
2948   arg0 = CALL_EXPR_ARG (exp, 0);
2949   arg1 = CALL_EXPR_ARG (exp, 1);
2950   mode = TYPE_MODE (TREE_TYPE (exp));
2951
2952   /* Emit a libcall to libgcc.  */
2953
2954   /* Mode of the 2nd argument must match that of an int.  */
2955   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
2956
2957   if (target == NULL_RTX)
2958     target = gen_reg_rtx (mode);
2959
2960   op0 = expand_expr (arg0, NULL_RTX, mode, EXPAND_NORMAL);
2961   if (GET_MODE (op0) != mode)
2962     op0 = convert_to_mode (mode, op0, 0);
2963   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
2964   if (GET_MODE (op1) != mode2)
2965     op1 = convert_to_mode (mode2, op1, 0);
2966
2967   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
2968                                     target, LCT_CONST, mode, 2,
2969                                     op0, mode, op1, mode2);
2970
2971   return target;
2972 }
2973
2974 /* Expand expression EXP which is a call to the strlen builtin.  Return
2975    NULL_RTX if we failed the caller should emit a normal call, otherwise
2976    try to get the result in TARGET, if convenient.  */
2977
2978 static rtx
2979 expand_builtin_strlen (tree exp, rtx target,
2980                        enum machine_mode target_mode)
2981 {
2982   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
2983     return NULL_RTX;
2984   else
2985     {
2986       struct expand_operand ops[4];
2987       rtx pat;
2988       tree len;
2989       tree src = CALL_EXPR_ARG (exp, 0);
2990       rtx src_reg, before_strlen;
2991       enum machine_mode insn_mode = target_mode;
2992       enum insn_code icode = CODE_FOR_nothing;
2993       unsigned int align;
2994
2995       /* If the length can be computed at compile-time, return it.  */
2996       len = c_strlen (src, 0);
2997       if (len)
2998         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2999
3000       /* If the length can be computed at compile-time and is constant
3001          integer, but there are side-effects in src, evaluate
3002          src for side-effects, then return len.
3003          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3004          can be optimized into: i++; x = 3;  */
3005       len = c_strlen (src, 1);
3006       if (len && TREE_CODE (len) == INTEGER_CST)
3007         {
3008           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3009           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3010         }
3011
3012       align = get_pointer_alignment (src) / BITS_PER_UNIT;
3013
3014       /* If SRC is not a pointer type, don't do this operation inline.  */
3015       if (align == 0)
3016         return NULL_RTX;
3017
3018       /* Bail out if we can't compute strlen in the right mode.  */
3019       while (insn_mode != VOIDmode)
3020         {
3021           icode = optab_handler (strlen_optab, insn_mode);
3022           if (icode != CODE_FOR_nothing)
3023             break;
3024
3025           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3026         }
3027       if (insn_mode == VOIDmode)
3028         return NULL_RTX;
3029
3030       /* Make a place to hold the source address.  We will not expand
3031          the actual source until we are sure that the expansion will
3032          not fail -- there are trees that cannot be expanded twice.  */
3033       src_reg = gen_reg_rtx (Pmode);
3034
3035       /* Mark the beginning of the strlen sequence so we can emit the
3036          source operand later.  */
3037       before_strlen = get_last_insn ();
3038
3039       create_output_operand (&ops[0], target, insn_mode);
3040       create_fixed_operand (&ops[1], gen_rtx_MEM (BLKmode, src_reg));
3041       create_integer_operand (&ops[2], 0);
3042       create_integer_operand (&ops[3], align);
3043       if (!maybe_expand_insn (icode, 4, ops))
3044         return NULL_RTX;
3045
3046       /* Now that we are assured of success, expand the source.  */
3047       start_sequence ();
3048       pat = expand_expr (src, src_reg, Pmode, EXPAND_NORMAL);
3049       if (pat != src_reg)
3050         {
3051 #ifdef POINTERS_EXTEND_UNSIGNED
3052           if (GET_MODE (pat) != Pmode)
3053             pat = convert_to_mode (Pmode, pat,
3054                                    POINTERS_EXTEND_UNSIGNED);
3055 #endif
3056           emit_move_insn (src_reg, pat);
3057         }
3058       pat = get_insns ();
3059       end_sequence ();
3060
3061       if (before_strlen)
3062         emit_insn_after (pat, before_strlen);
3063       else
3064         emit_insn_before (pat, get_insns ());
3065
3066       /* Return the value in the proper mode for this function.  */
3067       if (GET_MODE (ops[0].value) == target_mode)
3068         target = ops[0].value;
3069       else if (target != 0)
3070         convert_move (target, ops[0].value, 0);
3071       else
3072         target = convert_to_mode (target_mode, ops[0].value, 0);
3073
3074       return target;
3075     }
3076 }
3077
3078 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3079    bytes from constant string DATA + OFFSET and return it as target
3080    constant.  */
3081
3082 static rtx
3083 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3084                          enum machine_mode mode)
3085 {
3086   const char *str = (const char *) data;
3087
3088   gcc_assert (offset >= 0
3089               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3090                   <= strlen (str) + 1));
3091
3092   return c_readstr (str + offset, mode);
3093 }
3094
3095 /* Expand a call EXP to the memcpy builtin.
3096    Return NULL_RTX if we failed, the caller should emit a normal call,
3097    otherwise try to get the result in TARGET, if convenient (and in
3098    mode MODE if that's convenient).  */
3099
3100 static rtx
3101 expand_builtin_memcpy (tree exp, rtx target)
3102 {
3103   if (!validate_arglist (exp,
3104                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3105     return NULL_RTX;
3106   else
3107     {
3108       tree dest = CALL_EXPR_ARG (exp, 0);
3109       tree src = CALL_EXPR_ARG (exp, 1);
3110       tree len = CALL_EXPR_ARG (exp, 2);
3111       const char *src_str;
3112       unsigned int src_align = get_pointer_alignment (src);
3113       unsigned int dest_align = get_pointer_alignment (dest);
3114       rtx dest_mem, src_mem, dest_addr, len_rtx;
3115       HOST_WIDE_INT expected_size = -1;
3116       unsigned int expected_align = 0;
3117
3118       /* If DEST is not a pointer type, call the normal function.  */
3119       if (dest_align == 0)
3120         return NULL_RTX;
3121
3122       /* If either SRC is not a pointer type, don't do this
3123          operation in-line.  */
3124       if (src_align == 0)
3125         return NULL_RTX;
3126
3127       if (currently_expanding_gimple_stmt)
3128         stringop_block_profile (currently_expanding_gimple_stmt,
3129                                 &expected_align, &expected_size);
3130
3131       if (expected_align < dest_align)
3132         expected_align = dest_align;
3133       dest_mem = get_memory_rtx (dest, len);
3134       set_mem_align (dest_mem, dest_align);
3135       len_rtx = expand_normal (len);
3136       src_str = c_getstr (src);
3137
3138       /* If SRC is a string constant and block move would be done
3139          by pieces, we can avoid loading the string from memory
3140          and only stored the computed constants.  */
3141       if (src_str
3142           && CONST_INT_P (len_rtx)
3143           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3144           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3145                                   CONST_CAST (char *, src_str),
3146                                   dest_align, false))
3147         {
3148           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3149                                       builtin_memcpy_read_str,
3150                                       CONST_CAST (char *, src_str),
3151                                       dest_align, false, 0);
3152           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3153           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3154           return dest_mem;
3155         }
3156
3157       src_mem = get_memory_rtx (src, len);
3158       set_mem_align (src_mem, src_align);
3159
3160       /* Copy word part most expediently.  */
3161       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3162                                          CALL_EXPR_TAILCALL (exp)
3163                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3164                                          expected_align, expected_size);
3165
3166       if (dest_addr == 0)
3167         {
3168           dest_addr = force_operand (XEXP (dest_mem, 0), target);
3169           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3170         }
3171       return dest_addr;
3172     }
3173 }
3174
3175 /* Expand a call EXP to the mempcpy builtin.
3176    Return NULL_RTX if we failed; the caller should emit a normal call,
3177    otherwise try to get the result in TARGET, if convenient (and in
3178    mode MODE if that's convenient).  If ENDP is 0 return the
3179    destination pointer, if ENDP is 1 return the end pointer ala
3180    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3181    stpcpy.  */
3182
3183 static rtx
3184 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3185 {
3186   if (!validate_arglist (exp,
3187                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3188     return NULL_RTX;
3189   else
3190     {
3191       tree dest = CALL_EXPR_ARG (exp, 0);
3192       tree src = CALL_EXPR_ARG (exp, 1);
3193       tree len = CALL_EXPR_ARG (exp, 2);
3194       return expand_builtin_mempcpy_args (dest, src, len,
3195                                           target, mode, /*endp=*/ 1);
3196     }
3197 }
3198
3199 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3200    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3201    so that this can also be called without constructing an actual CALL_EXPR.
3202    The other arguments and return value are the same as for
3203    expand_builtin_mempcpy.  */
3204
3205 static rtx
3206 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3207                              rtx target, enum machine_mode mode, int endp)
3208 {
3209     /* If return value is ignored, transform mempcpy into memcpy.  */
3210   if (target == const0_rtx && builtin_decl_implicit_p (BUILT_IN_MEMCPY))
3211     {
3212       tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
3213       tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3214                                            dest, src, len);
3215       return expand_expr (result, target, mode, EXPAND_NORMAL);
3216     }
3217   else
3218     {
3219       const char *src_str;
3220       unsigned int src_align = get_pointer_alignment (src);
3221       unsigned int dest_align = get_pointer_alignment (dest);
3222       rtx dest_mem, src_mem, len_rtx;
3223
3224       /* If either SRC or DEST is not a pointer type, don't do this
3225          operation in-line.  */
3226       if (dest_align == 0 || src_align == 0)
3227         return NULL_RTX;
3228
3229       /* If LEN is not constant, call the normal function.  */
3230       if (! host_integerp (len, 1))
3231         return NULL_RTX;
3232
3233       len_rtx = expand_normal (len);
3234       src_str = c_getstr (src);
3235
3236       /* If SRC is a string constant and block move would be done
3237          by pieces, we can avoid loading the string from memory
3238          and only stored the computed constants.  */
3239       if (src_str
3240           && CONST_INT_P (len_rtx)
3241           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3242           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3243                                   CONST_CAST (char *, src_str),
3244                                   dest_align, false))
3245         {
3246           dest_mem = get_memory_rtx (dest, len);
3247           set_mem_align (dest_mem, dest_align);
3248           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3249                                       builtin_memcpy_read_str,
3250                                       CONST_CAST (char *, src_str),
3251                                       dest_align, false, endp);
3252           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3253           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3254           return dest_mem;
3255         }
3256
3257       if (CONST_INT_P (len_rtx)
3258           && can_move_by_pieces (INTVAL (len_rtx),
3259                                  MIN (dest_align, src_align)))
3260         {
3261           dest_mem = get_memory_rtx (dest, len);
3262           set_mem_align (dest_mem, dest_align);
3263           src_mem = get_memory_rtx (src, len);
3264           set_mem_align (src_mem, src_align);
3265           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3266                                      MIN (dest_align, src_align), endp);
3267           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3268           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3269           return dest_mem;
3270         }
3271
3272       return NULL_RTX;
3273     }
3274 }
3275
3276 #ifndef HAVE_movstr
3277 # define HAVE_movstr 0
3278 # define CODE_FOR_movstr CODE_FOR_nothing
3279 #endif
3280
3281 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3282    we failed, the caller should emit a normal call, otherwise try to
3283    get the result in TARGET, if convenient.  If ENDP is 0 return the
3284    destination pointer, if ENDP is 1 return the end pointer ala
3285    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3286    stpcpy.  */
3287
3288 static rtx
3289 expand_movstr (tree dest, tree src, rtx target, int endp)
3290 {
3291   struct expand_operand ops[3];
3292   rtx dest_mem;
3293   rtx src_mem;
3294
3295   if (!HAVE_movstr)
3296     return NULL_RTX;
3297
3298   dest_mem = get_memory_rtx (dest, NULL);
3299   src_mem = get_memory_rtx (src, NULL);
3300   if (!endp)
3301     {
3302       target = force_reg (Pmode, XEXP (dest_mem, 0));
3303       dest_mem = replace_equiv_address (dest_mem, target);
3304     }
3305
3306   create_output_operand (&ops[0], endp ? target : NULL_RTX, Pmode);
3307   create_fixed_operand (&ops[1], dest_mem);
3308   create_fixed_operand (&ops[2], src_mem);
3309   expand_insn (CODE_FOR_movstr, 3, ops);
3310
3311   if (endp && target != const0_rtx)
3312     {
3313       target = ops[0].value;
3314       /* movstr is supposed to set end to the address of the NUL
3315          terminator.  If the caller requested a mempcpy-like return value,
3316          adjust it.  */
3317       if (endp == 1)
3318         {
3319           rtx tem = plus_constant (gen_lowpart (GET_MODE (target), target), 1);
3320           emit_move_insn (target, force_operand (tem, NULL_RTX));
3321         }
3322     }
3323   return target;
3324 }
3325
3326 /* Expand expression EXP, which is a call to the strcpy builtin.  Return
3327    NULL_RTX if we failed the caller should emit a normal call, otherwise
3328    try to get the result in TARGET, if convenient (and in mode MODE if that's
3329    convenient).  */
3330
3331 static rtx
3332 expand_builtin_strcpy (tree exp, rtx target)
3333 {
3334   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3335    {
3336      tree dest = CALL_EXPR_ARG (exp, 0);
3337      tree src = CALL_EXPR_ARG (exp, 1);
3338      return expand_builtin_strcpy_args (dest, src, target);
3339    }
3340    return NULL_RTX;
3341 }
3342
3343 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3344    arguments to the builtin_strcpy call DEST and SRC are broken out
3345    so that this can also be called without constructing an actual CALL_EXPR.
3346    The other arguments and return value are the same as for
3347    expand_builtin_strcpy.  */
3348
3349 static rtx
3350 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3351 {
3352   return expand_movstr (dest, src, target, /*endp=*/0);
3353 }
3354
3355 /* Expand a call EXP to the stpcpy builtin.
3356    Return NULL_RTX if we failed the caller should emit a normal call,
3357    otherwise try to get the result in TARGET, if convenient (and in
3358    mode MODE if that's convenient).  */
3359
3360 static rtx
3361 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3362 {
3363   tree dst, src;
3364   location_t loc = EXPR_LOCATION (exp);
3365
3366   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3367     return NULL_RTX;
3368
3369   dst = CALL_EXPR_ARG (exp, 0);
3370   src = CALL_EXPR_ARG (exp, 1);
3371
3372   /* If return value is ignored, transform stpcpy into strcpy.  */
3373   if (target == const0_rtx && builtin_decl_implicit (BUILT_IN_STRCPY))
3374     {
3375       tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
3376       tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3377       return expand_expr (result, target, mode, EXPAND_NORMAL);
3378     }
3379   else
3380     {
3381       tree len, lenp1;
3382       rtx ret;
3383
3384       /* Ensure we get an actual string whose length can be evaluated at
3385          compile-time, not an expression containing a string.  This is
3386          because the latter will potentially produce pessimized code
3387          when used to produce the return value.  */
3388       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3389         return expand_movstr (dst, src, target, /*endp=*/2);
3390
3391       lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3392       ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3393                                          target, mode, /*endp=*/2);
3394
3395       if (ret)
3396         return ret;
3397
3398       if (TREE_CODE (len) == INTEGER_CST)
3399         {
3400           rtx len_rtx = expand_normal (len);
3401
3402           if (CONST_INT_P (len_rtx))
3403             {
3404               ret = expand_builtin_strcpy_args (dst, src, target);
3405
3406               if (ret)
3407                 {
3408                   if (! target)
3409                     {
3410                       if (mode != VOIDmode)
3411                         target = gen_reg_rtx (mode);
3412                       else
3413                         target = gen_reg_rtx (GET_MODE (ret));
3414                     }
3415                   if (GET_MODE (target) != GET_MODE (ret))
3416                     ret = gen_lowpart (GET_MODE (target), ret);
3417
3418                   ret = plus_constant (ret, INTVAL (len_rtx));
3419                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3420                   gcc_assert (ret);
3421
3422                   return target;
3423                 }
3424             }
3425         }
3426
3427       return expand_movstr (dst, src, target, /*endp=*/2);
3428     }
3429 }
3430
3431 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3432    bytes from constant string DATA + OFFSET and return it as target
3433    constant.  */
3434
3435 rtx
3436 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3437                           enum machine_mode mode)
3438 {
3439   const char *str = (const char *) data;
3440
3441   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3442     return const0_rtx;
3443
3444   return c_readstr (str + offset, mode);
3445 }
3446
3447 /* Expand expression EXP, which is a call to the strncpy builtin.  Return
3448    NULL_RTX if we failed the caller should emit a normal call.  */
3449
3450 static rtx
3451 expand_builtin_strncpy (tree exp, rtx target)
3452 {
3453   location_t loc = EXPR_LOCATION (exp);
3454
3455   if (validate_arglist (exp,
3456                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3457     {
3458       tree dest = CALL_EXPR_ARG (exp, 0);
3459       tree src = CALL_EXPR_ARG (exp, 1);
3460       tree len = CALL_EXPR_ARG (exp, 2);
3461       tree slen = c_strlen (src, 1);
3462
3463       /* We must be passed a constant len and src parameter.  */
3464       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3465         return NULL_RTX;
3466
3467       slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3468
3469       /* We're required to pad with trailing zeros if the requested
3470          len is greater than strlen(s2)+1.  In that case try to
3471          use store_by_pieces, if it fails, punt.  */
3472       if (tree_int_cst_lt (slen, len))
3473         {
3474           unsigned int dest_align = get_pointer_alignment (dest);
3475           const char *p = c_getstr (src);
3476           rtx dest_mem;
3477
3478           if (!p || dest_align == 0 || !host_integerp (len, 1)
3479               || !can_store_by_pieces (tree_low_cst (len, 1),
3480                                        builtin_strncpy_read_str,
3481                                        CONST_CAST (char *, p),
3482                                        dest_align, false))
3483             return NULL_RTX;
3484
3485           dest_mem = get_memory_rtx (dest, len);
3486           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3487                            builtin_strncpy_read_str,
3488                            CONST_CAST (char *, p), dest_align, false, 0);
3489           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3490           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3491           return dest_mem;
3492         }
3493     }
3494   return NULL_RTX;
3495 }
3496
3497 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3498    bytes from constant string DATA + OFFSET and return it as target
3499    constant.  */
3500
3501 rtx
3502 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3503                          enum machine_mode mode)
3504 {
3505   const char *c = (const char *) data;
3506   char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3507
3508   memset (p, *c, GET_MODE_SIZE (mode));
3509
3510   return c_readstr (p, mode);
3511 }
3512
3513 /* Callback routine for store_by_pieces.  Return the RTL of a register
3514    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3515    char value given in the RTL register data.  For example, if mode is
3516    4 bytes wide, return the RTL for 0x01010101*data.  */
3517
3518 static rtx
3519 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3520                         enum machine_mode mode)
3521 {
3522   rtx target, coeff;
3523   size_t size;
3524   char *p;
3525
3526   size = GET_MODE_SIZE (mode);
3527   if (size == 1)
3528     return (rtx) data;
3529
3530   p = XALLOCAVEC (char, size);
3531   memset (p, 1, size);
3532   coeff = c_readstr (p, mode);
3533
3534   target = convert_to_mode (mode, (rtx) data, 1);
3535   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3536   return force_reg (mode, target);
3537 }
3538
3539 /* Expand expression EXP, which is a call to the memset builtin.  Return
3540    NULL_RTX if we failed the caller should emit a normal call, otherwise
3541    try to get the result in TARGET, if convenient (and in mode MODE if that's
3542    convenient).  */
3543
3544 static rtx
3545 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3546 {
3547   if (!validate_arglist (exp,
3548                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3549     return NULL_RTX;
3550   else
3551     {
3552       tree dest = CALL_EXPR_ARG (exp, 0);
3553       tree val = CALL_EXPR_ARG (exp, 1);
3554       tree len = CALL_EXPR_ARG (exp, 2);
3555       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3556     }
3557 }
3558
3559 /* Helper function to do the actual work for expand_builtin_memset.  The
3560    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3561    so that this can also be called without constructing an actual CALL_EXPR.
3562    The other arguments and return value are the same as for
3563    expand_builtin_memset.  */
3564
3565 static rtx
3566 expand_builtin_memset_args (tree dest, tree val, tree len,
3567                             rtx target, enum machine_mode mode, tree orig_exp)
3568 {
3569   tree fndecl, fn;
3570   enum built_in_function fcode;
3571   enum machine_mode val_mode;
3572   char c;
3573   unsigned int dest_align;
3574   rtx dest_mem, dest_addr, len_rtx;
3575   HOST_WIDE_INT expected_size = -1;
3576   unsigned int expected_align = 0;
3577
3578   dest_align = get_pointer_alignment (dest);
3579
3580   /* If DEST is not a pointer type, don't do this operation in-line.  */
3581   if (dest_align == 0)
3582     return NULL_RTX;
3583
3584   if (currently_expanding_gimple_stmt)
3585     stringop_block_profile (currently_expanding_gimple_stmt,
3586                             &expected_align, &expected_size);
3587
3588   if (expected_align < dest_align)
3589     expected_align = dest_align;
3590
3591   /* If the LEN parameter is zero, return DEST.  */
3592   if (integer_zerop (len))
3593     {
3594       /* Evaluate and ignore VAL in case it has side-effects.  */
3595       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3596       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3597     }
3598
3599   /* Stabilize the arguments in case we fail.  */
3600   dest = builtin_save_expr (dest);
3601   val = builtin_save_expr (val);
3602   len = builtin_save_expr (len);
3603
3604   len_rtx = expand_normal (len);
3605   dest_mem = get_memory_rtx (dest, len);
3606   val_mode = TYPE_MODE (unsigned_char_type_node);
3607
3608   if (TREE_CODE (val) != INTEGER_CST)
3609     {
3610       rtx val_rtx;
3611
3612       val_rtx = expand_normal (val);
3613       val_rtx = convert_to_mode (val_mode, val_rtx, 0);
3614
3615       /* Assume that we can memset by pieces if we can store
3616        * the coefficients by pieces (in the required modes).
3617        * We can't pass builtin_memset_gen_str as that emits RTL.  */
3618       c = 1;
3619       if (host_integerp (len, 1)
3620           && can_store_by_pieces (tree_low_cst (len, 1),
3621                                   builtin_memset_read_str, &c, dest_align,
3622                                   true))
3623         {
3624           val_rtx = force_reg (val_mode, val_rtx);
3625           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3626                            builtin_memset_gen_str, val_rtx, dest_align,
3627                            true, 0);
3628         }
3629       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3630                                         dest_align, expected_align,
3631                                         expected_size))
3632         goto do_libcall;
3633
3634       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3635       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3636       return dest_mem;
3637     }
3638
3639   if (target_char_cast (val, &c))
3640     goto do_libcall;
3641
3642   if (c)
3643     {
3644       if (host_integerp (len, 1)
3645           && can_store_by_pieces (tree_low_cst (len, 1),
3646                                   builtin_memset_read_str, &c, dest_align,
3647                                   true))
3648         store_by_pieces (dest_mem, tree_low_cst (len, 1),
3649                          builtin_memset_read_str, &c, dest_align, true, 0);
3650       else if (!set_storage_via_setmem (dest_mem, len_rtx,
3651                                         gen_int_mode (c, val_mode),
3652                                         dest_align, expected_align,
3653                                         expected_size))
3654         goto do_libcall;
3655
3656       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3657       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3658       return dest_mem;
3659     }
3660
3661   set_mem_align (dest_mem, dest_align);
3662   dest_addr = clear_storage_hints (dest_mem, len_rtx,
3663                                    CALL_EXPR_TAILCALL (orig_exp)
3664                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3665                                    expected_align, expected_size);
3666
3667   if (dest_addr == 0)
3668     {
3669       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3670       dest_addr = convert_memory_address (ptr_mode, dest_addr);
3671     }
3672
3673   return dest_addr;
3674
3675  do_libcall:
3676   fndecl = get_callee_fndecl (orig_exp);
3677   fcode = DECL_FUNCTION_CODE (fndecl);
3678   if (fcode == BUILT_IN_MEMSET)
3679     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
3680                                 dest, val, len);
3681   else if (fcode == BUILT_IN_BZERO)
3682     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
3683                                 dest, len);
3684   else
3685     gcc_unreachable ();
3686   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3687   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3688   return expand_call (fn, target, target == const0_rtx);
3689 }
3690
3691 /* Expand expression EXP, which is a call to the bzero builtin.  Return
3692    NULL_RTX if we failed the caller should emit a normal call.  */
3693
3694 static rtx
3695 expand_builtin_bzero (tree exp)
3696 {
3697   tree dest, size;
3698   location_t loc = EXPR_LOCATION (exp);
3699
3700   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3701     return NULL_RTX;
3702
3703   dest = CALL_EXPR_ARG (exp, 0);
3704   size = CALL_EXPR_ARG (exp, 1);
3705
3706   /* New argument list transforming bzero(ptr x, int y) to
3707      memset(ptr x, int 0, size_t y).   This is done this way
3708      so that if it isn't expanded inline, we fallback to
3709      calling bzero instead of memset.  */
3710
3711   return expand_builtin_memset_args (dest, integer_zero_node,
3712                                      fold_convert_loc (loc,
3713                                                        size_type_node, size),
3714                                      const0_rtx, VOIDmode, exp);
3715 }
3716
3717 /* Expand expression EXP, which is a call to the memcmp built-in function.
3718    Return NULL_RTX if we failed and the caller should emit a normal call,
3719    otherwise try to get the result in TARGET, if convenient (and in mode
3720    MODE, if that's convenient).  */
3721
3722 static rtx
3723 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3724                        ATTRIBUTE_UNUSED enum machine_mode mode)
3725 {
3726   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
3727
3728   if (!validate_arglist (exp,
3729                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3730     return NULL_RTX;
3731
3732   /* Note: The cmpstrnsi pattern, if it exists, is not suitable for
3733      implementing memcmp because it will stop if it encounters two
3734      zero bytes.  */
3735 #if defined HAVE_cmpmemsi
3736   {
3737     rtx arg1_rtx, arg2_rtx, arg3_rtx;
3738     rtx result;
3739     rtx insn;
3740     tree arg1 = CALL_EXPR_ARG (exp, 0);
3741     tree arg2 = CALL_EXPR_ARG (exp, 1);
3742     tree len = CALL_EXPR_ARG (exp, 2);
3743
3744     unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3745     unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3746     enum machine_mode insn_mode;
3747
3748     if (HAVE_cmpmemsi)
3749       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
3750     else
3751       return NULL_RTX;
3752
3753     /* If we don't have POINTER_TYPE, call the function.  */
3754     if (arg1_align == 0 || arg2_align == 0)
3755       return NULL_RTX;
3756
3757     /* Make a place to write the result of the instruction.  */
3758     result = target;
3759     if (! (result != 0
3760            && REG_P (result) && GET_MODE (result) == insn_mode
3761            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3762       result = gen_reg_rtx (insn_mode);
3763
3764     arg1_rtx = get_memory_rtx (arg1, len);
3765     arg2_rtx = get_memory_rtx (arg2, len);
3766     arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
3767
3768     /* Set MEM_SIZE as appropriate.  */
3769     if (CONST_INT_P (arg3_rtx))
3770       {
3771         set_mem_size (arg1_rtx, INTVAL (arg3_rtx));
3772         set_mem_size (arg2_rtx, INTVAL (arg3_rtx));
3773       }
3774
3775     if (HAVE_cmpmemsi)
3776       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3777                            GEN_INT (MIN (arg1_align, arg2_align)));
3778     else
3779       gcc_unreachable ();
3780
3781     if (insn)
3782       emit_insn (insn);
3783     else
3784       emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
3785                                TYPE_MODE (integer_type_node), 3,
3786                                XEXP (arg1_rtx, 0), Pmode,
3787                                XEXP (arg2_rtx, 0), Pmode,
3788                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3789                                                 TYPE_UNSIGNED (sizetype)),
3790                                TYPE_MODE (sizetype));
3791
3792     /* Return the value in the proper mode for this function.  */
3793     mode = TYPE_MODE (TREE_TYPE (exp));
3794     if (GET_MODE (result) == mode)
3795       return result;
3796     else if (target != 0)
3797       {
3798         convert_move (target, result, 0);
3799         return target;
3800       }
3801     else
3802       return convert_to_mode (mode, result, 0);
3803   }
3804 #endif /* HAVE_cmpmemsi.  */
3805
3806   return NULL_RTX;
3807 }
3808
3809 /* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
3810    if we failed the caller should emit a normal call, otherwise try to get
3811    the result in TARGET, if convenient.  */
3812
3813 static rtx
3814 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
3815 {
3816   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3817     return NULL_RTX;
3818
3819 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
3820   if (direct_optab_handler (cmpstr_optab, SImode) != CODE_FOR_nothing
3821       || direct_optab_handler (cmpstrn_optab, SImode) != CODE_FOR_nothing)
3822     {
3823       rtx arg1_rtx, arg2_rtx;
3824       rtx result, insn = NULL_RTX;
3825       tree fndecl, fn;
3826       tree arg1 = CALL_EXPR_ARG (exp, 0);
3827       tree arg2 = CALL_EXPR_ARG (exp, 1);
3828
3829       unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3830       unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3831
3832       /* If we don't have POINTER_TYPE, call the function.  */
3833       if (arg1_align == 0 || arg2_align == 0)
3834         return NULL_RTX;
3835
3836       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
3837       arg1 = builtin_save_expr (arg1);
3838       arg2 = builtin_save_expr (arg2);
3839
3840       arg1_rtx = get_memory_rtx (arg1, NULL);
3841       arg2_rtx = get_memory_rtx (arg2, NULL);
3842
3843 #ifdef HAVE_cmpstrsi
3844       /* Try to call cmpstrsi.  */
3845       if (HAVE_cmpstrsi)
3846         {
3847           enum machine_mode insn_mode
3848             = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3849
3850           /* Make a place to write the result of the instruction.  */
3851           result = target;
3852           if (! (result != 0
3853                  && REG_P (result) && GET_MODE (result) == insn_mode
3854                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3855             result = gen_reg_rtx (insn_mode);
3856
3857           insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
3858                                GEN_INT (MIN (arg1_align, arg2_align)));
3859         }
3860 #endif
3861 #ifdef HAVE_cmpstrnsi
3862       /* Try to determine at least one length and call cmpstrnsi.  */
3863       if (!insn && HAVE_cmpstrnsi)
3864         {
3865           tree len;
3866           rtx arg3_rtx;
3867
3868           enum machine_mode insn_mode
3869             = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3870           tree len1 = c_strlen (arg1, 1);
3871           tree len2 = c_strlen (arg2, 1);
3872
3873           if (len1)
3874             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3875           if (len2)
3876             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3877
3878           /* If we don't have a constant length for the first, use the length
3879              of the second, if we know it.  We don't require a constant for
3880              this case; some cost analysis could be done if both are available
3881              but neither is constant.  For now, assume they're equally cheap,
3882              unless one has side effects.  If both strings have constant lengths,
3883              use the smaller.  */
3884
3885           if (!len1)
3886             len = len2;
3887           else if (!len2)
3888             len = len1;
3889           else if (TREE_SIDE_EFFECTS (len1))
3890             len = len2;
3891           else if (TREE_SIDE_EFFECTS (len2))
3892             len = len1;
3893           else if (TREE_CODE (len1) != INTEGER_CST)
3894             len = len2;
3895           else if (TREE_CODE (len2) != INTEGER_CST)
3896             len = len1;
3897           else if (tree_int_cst_lt (len1, len2))
3898             len = len1;
3899           else
3900             len = len2;
3901
3902           /* If both arguments have side effects, we cannot optimize.  */
3903           if (!len || TREE_SIDE_EFFECTS (len))
3904             goto do_libcall;
3905
3906           arg3_rtx = expand_normal (len);
3907
3908           /* Make a place to write the result of the instruction.  */
3909           result = target;
3910           if (! (result != 0
3911                  && REG_P (result) && GET_MODE (result) == insn_mode
3912                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3913             result = gen_reg_rtx (insn_mode);
3914
3915           insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3916                                 GEN_INT (MIN (arg1_align, arg2_align)));
3917         }
3918 #endif
3919
3920       if (insn)
3921         {
3922           enum machine_mode mode;
3923           emit_insn (insn);
3924
3925           /* Return the value in the proper mode for this function.  */
3926           mode = TYPE_MODE (TREE_TYPE (exp));
3927           if (GET_MODE (result) == mode)
3928             return result;
3929           if (target == 0)
3930             return convert_to_mode (mode, result, 0);
3931           convert_move (target, result, 0);
3932           return target;
3933         }
3934
3935       /* Expand the library call ourselves using a stabilized argument
3936          list to avoid re-evaluating the function's arguments twice.  */
3937 #ifdef HAVE_cmpstrnsi
3938     do_libcall:
3939 #endif
3940       fndecl = get_callee_fndecl (exp);
3941       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
3942       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3943       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
3944       return expand_call (fn, target, target == const0_rtx);
3945     }
3946 #endif
3947   return NULL_RTX;
3948 }
3949
3950 /* Expand expression EXP, which is a call to the strncmp builtin. Return
3951    NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
3952    the result in TARGET, if convenient.  */
3953
3954 static rtx
3955 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3956                         ATTRIBUTE_UNUSED enum machine_mode mode)
3957 {
3958   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
3959
3960   if (!validate_arglist (exp,
3961                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3962     return NULL_RTX;
3963
3964   /* If c_strlen can determine an expression for one of the string
3965      lengths, and it doesn't have side effects, then emit cmpstrnsi
3966      using length MIN(strlen(string)+1, arg3).  */
3967 #ifdef HAVE_cmpstrnsi
3968   if (HAVE_cmpstrnsi)
3969   {
3970     tree len, len1, len2;
3971     rtx arg1_rtx, arg2_rtx, arg3_rtx;
3972     rtx result, insn;
3973     tree fndecl, fn;
3974     tree arg1 = CALL_EXPR_ARG (exp, 0);
3975     tree arg2 = CALL_EXPR_ARG (exp, 1);
3976     tree arg3 = CALL_EXPR_ARG (exp, 2);
3977
3978     unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3979     unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3980     enum machine_mode insn_mode
3981       = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3982
3983     len1 = c_strlen (arg1, 1);
3984     len2 = c_strlen (arg2, 1);
3985
3986     if (len1)
3987       len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
3988     if (len2)
3989       len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
3990
3991     /* If we don't have a constant length for the first, use the length
3992        of the second, if we know it.  We don't require a constant for
3993        this case; some cost analysis could be done if both are available
3994        but neither is constant.  For now, assume they're equally cheap,
3995        unless one has side effects.  If both strings have constant lengths,
3996        use the smaller.  */
3997
3998     if (!len1)
3999       len = len2;
4000     else if (!len2)
4001       len = len1;
4002     else if (TREE_SIDE_EFFECTS (len1))
4003       len = len2;
4004     else if (TREE_SIDE_EFFECTS (len2))
4005       len = len1;
4006     else if (TREE_CODE (len1) != INTEGER_CST)
4007       len = len2;
4008     else if (TREE_CODE (len2) != INTEGER_CST)
4009       len = len1;
4010     else if (tree_int_cst_lt (len1, len2))
4011       len = len1;
4012     else
4013       len = len2;
4014
4015     /* If both arguments have side effects, we cannot optimize.  */
4016     if (!len || TREE_SIDE_EFFECTS (len))
4017       return NULL_RTX;
4018
4019     /* The actual new length parameter is MIN(len,arg3).  */
4020     len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4021                        fold_convert_loc (loc, TREE_TYPE (len), arg3));
4022
4023     /* If we don't have POINTER_TYPE, call the function.  */
4024     if (arg1_align == 0 || arg2_align == 0)
4025       return NULL_RTX;
4026
4027     /* Make a place to write the result of the instruction.  */
4028     result = target;
4029     if (! (result != 0
4030            && REG_P (result) && GET_MODE (result) == insn_mode
4031            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4032       result = gen_reg_rtx (insn_mode);
4033
4034     /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
4035     arg1 = builtin_save_expr (arg1);
4036     arg2 = builtin_save_expr (arg2);
4037     len = builtin_save_expr (len);
4038
4039     arg1_rtx = get_memory_rtx (arg1, len);
4040     arg2_rtx = get_memory_rtx (arg2, len);
4041     arg3_rtx = expand_normal (len);
4042     insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4043                           GEN_INT (MIN (arg1_align, arg2_align)));
4044     if (insn)
4045       {
4046         emit_insn (insn);
4047
4048         /* Return the value in the proper mode for this function.  */
4049         mode = TYPE_MODE (TREE_TYPE (exp));
4050         if (GET_MODE (result) == mode)
4051           return result;
4052         if (target == 0)
4053           return convert_to_mode (mode, result, 0);
4054         convert_move (target, result, 0);
4055         return target;
4056       }
4057
4058     /* Expand the library call ourselves using a stabilized argument
4059        list to avoid re-evaluating the function's arguments twice.  */
4060     fndecl = get_callee_fndecl (exp);
4061     fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
4062                                 arg1, arg2, len);
4063     gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4064     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4065     return expand_call (fn, target, target == const0_rtx);
4066   }
4067 #endif
4068   return NULL_RTX;
4069 }
4070
4071 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4072    if that's convenient.  */
4073
4074 rtx
4075 expand_builtin_saveregs (void)
4076 {
4077   rtx val, seq;
4078
4079   /* Don't do __builtin_saveregs more than once in a function.
4080      Save the result of the first call and reuse it.  */
4081   if (saveregs_value != 0)
4082     return saveregs_value;
4083
4084   /* When this function is called, it means that registers must be
4085      saved on entry to this function.  So we migrate the call to the
4086      first insn of this function.  */
4087
4088   start_sequence ();
4089
4090   /* Do whatever the machine needs done in this case.  */
4091   val = targetm.calls.expand_builtin_saveregs ();
4092
4093   seq = get_insns ();
4094   end_sequence ();
4095
4096   saveregs_value = val;
4097
4098   /* Put the insns after the NOTE that starts the function.  If this
4099      is inside a start_sequence, make the outer-level insn chain current, so
4100      the code is placed at the start of the function.  */
4101   push_topmost_sequence ();
4102   emit_insn_after (seq, entry_of_function ());
4103   pop_topmost_sequence ();
4104
4105   return val;
4106 }
4107
4108 /* Expand a call to __builtin_next_arg.  */
4109
4110 static rtx
4111 expand_builtin_next_arg (void)
4112 {
4113   /* Checking arguments is already done in fold_builtin_next_arg
4114      that must be called before this function.  */
4115   return expand_binop (ptr_mode, add_optab,
4116                        crtl->args.internal_arg_pointer,
4117                        crtl->args.arg_offset_rtx,
4118                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
4119 }
4120
4121 /* Make it easier for the backends by protecting the valist argument
4122    from multiple evaluations.  */
4123
4124 static tree
4125 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4126 {
4127   tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4128
4129   /* The current way of determining the type of valist is completely
4130      bogus.  We should have the information on the va builtin instead.  */
4131   if (!vatype)
4132     vatype = targetm.fn_abi_va_list (cfun->decl);
4133
4134   if (TREE_CODE (vatype) == ARRAY_TYPE)
4135     {
4136       if (TREE_SIDE_EFFECTS (valist))
4137         valist = save_expr (valist);
4138
4139       /* For this case, the backends will be expecting a pointer to
4140          vatype, but it's possible we've actually been given an array
4141          (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4142          So fix it.  */
4143       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4144         {
4145           tree p1 = build_pointer_type (TREE_TYPE (vatype));
4146           valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4147         }
4148     }
4149   else
4150     {
4151       tree pt = build_pointer_type (vatype);
4152
4153       if (! needs_lvalue)
4154         {
4155           if (! TREE_SIDE_EFFECTS (valist))
4156             return valist;
4157
4158           valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4159           TREE_SIDE_EFFECTS (valist) = 1;
4160         }
4161
4162       if (TREE_SIDE_EFFECTS (valist))
4163         valist = save_expr (valist);
4164       valist = fold_build2_loc (loc, MEM_REF,
4165                                 vatype, valist, build_int_cst (pt, 0));
4166     }
4167
4168   return valist;
4169 }
4170
4171 /* The "standard" definition of va_list is void*.  */
4172
4173 tree
4174 std_build_builtin_va_list (void)
4175 {
4176   return ptr_type_node;
4177 }
4178
4179 /* The "standard" abi va_list is va_list_type_node.  */
4180
4181 tree
4182 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4183 {
4184   return va_list_type_node;
4185 }
4186
4187 /* The "standard" type of va_list is va_list_type_node.  */
4188
4189 tree
4190 std_canonical_va_list_type (tree type)
4191 {
4192   tree wtype, htype;
4193
4194   if (INDIRECT_REF_P (type))
4195     type = TREE_TYPE (type);
4196   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4197     type = TREE_TYPE (type);
4198   wtype = va_list_type_node;
4199   htype = type;
4200   /* Treat structure va_list types.  */
4201   if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4202     htype = TREE_TYPE (htype);
4203   else if (TREE_CODE (wtype) == ARRAY_TYPE)
4204     {
4205       /* If va_list is an array type, the argument may have decayed
4206          to a pointer type, e.g. by being passed to another function.
4207          In that case, unwrap both types so that we can compare the
4208          underlying records.  */
4209       if (TREE_CODE (htype) == ARRAY_TYPE
4210           || POINTER_TYPE_P (htype))
4211         {
4212           wtype = TREE_TYPE (wtype);
4213           htype = TREE_TYPE (htype);
4214         }
4215     }
4216   if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4217     return va_list_type_node;
4218
4219   return NULL_TREE;
4220 }
4221
4222 /* The "standard" implementation of va_start: just assign `nextarg' to
4223    the variable.  */
4224
4225 void
4226 std_expand_builtin_va_start (tree valist, rtx nextarg)
4227 {
4228   rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4229   convert_move (va_r, nextarg, 0);
4230 }
4231
4232 /* Expand EXP, a call to __builtin_va_start.  */
4233
4234 static rtx
4235 expand_builtin_va_start (tree exp)
4236 {
4237   rtx nextarg;
4238   tree valist;
4239   location_t loc = EXPR_LOCATION (exp);
4240
4241   if (call_expr_nargs (exp) < 2)
4242     {
4243       error_at (loc, "too few arguments to function %<va_start%>");
4244       return const0_rtx;
4245     }
4246
4247   if (fold_builtin_next_arg (exp, true))
4248     return const0_rtx;
4249
4250   nextarg = expand_builtin_next_arg ();
4251   valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4252
4253   if (targetm.expand_builtin_va_start)
4254     targetm.expand_builtin_va_start (valist, nextarg);
4255   else
4256     std_expand_builtin_va_start (valist, nextarg);
4257
4258   return const0_rtx;
4259 }
4260
4261 /* The "standard" implementation of va_arg: read the value from the
4262    current (padded) address and increment by the (padded) size.  */
4263
4264 tree
4265 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4266                           gimple_seq *post_p)
4267 {
4268   tree addr, t, type_size, rounded_size, valist_tmp;
4269   unsigned HOST_WIDE_INT align, boundary;
4270   bool indirect;
4271
4272 #ifdef ARGS_GROW_DOWNWARD
4273   /* All of the alignment and movement below is for args-grow-up machines.
4274      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4275      implement their own specialized gimplify_va_arg_expr routines.  */
4276   gcc_unreachable ();
4277 #endif
4278
4279   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4280   if (indirect)
4281     type = build_pointer_type (type);
4282
4283   align = PARM_BOUNDARY / BITS_PER_UNIT;
4284   boundary = targetm.calls.function_arg_boundary (TYPE_MODE (type), type);
4285
4286   /* When we align parameter on stack for caller, if the parameter
4287      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4288      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
4289      here with caller.  */
4290   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4291     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4292
4293   boundary /= BITS_PER_UNIT;
4294
4295   /* Hoist the valist value into a temporary for the moment.  */
4296   valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4297
4298   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
4299      requires greater alignment, we must perform dynamic alignment.  */
4300   if (boundary > align
4301       && !integer_zerop (TYPE_SIZE (type)))
4302     {
4303       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4304                   fold_build_pointer_plus_hwi (valist_tmp, boundary - 1));
4305       gimplify_and_add (t, pre_p);
4306
4307       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4308                   fold_build2 (BIT_AND_EXPR, TREE_TYPE (valist),
4309                                valist_tmp,
4310                                build_int_cst (TREE_TYPE (valist), -boundary)));
4311       gimplify_and_add (t, pre_p);
4312     }
4313   else
4314     boundary = align;
4315
4316   /* If the actual alignment is less than the alignment of the type,
4317      adjust the type accordingly so that we don't assume strict alignment
4318      when dereferencing the pointer.  */
4319   boundary *= BITS_PER_UNIT;
4320   if (boundary < TYPE_ALIGN (type))
4321     {
4322       type = build_variant_type_copy (type);
4323       TYPE_ALIGN (type) = boundary;
4324     }
4325
4326   /* Compute the rounded size of the type.  */
4327   type_size = size_in_bytes (type);
4328   rounded_size = round_up (type_size, align);
4329
4330   /* Reduce rounded_size so it's sharable with the postqueue.  */
4331   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4332
4333   /* Get AP.  */
4334   addr = valist_tmp;
4335   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4336     {
4337       /* Small args are padded downward.  */
4338       t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4339                        rounded_size, size_int (align));
4340       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4341                        size_binop (MINUS_EXPR, rounded_size, type_size));
4342       addr = fold_build_pointer_plus (addr, t);
4343     }
4344
4345   /* Compute new value for AP.  */
4346   t = fold_build_pointer_plus (valist_tmp, rounded_size);
4347   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4348   gimplify_and_add (t, pre_p);
4349
4350   addr = fold_convert (build_pointer_type (type), addr);
4351
4352   if (indirect)
4353     addr = build_va_arg_indirect_ref (addr);
4354
4355   return build_va_arg_indirect_ref (addr);
4356 }
4357
4358 /* Build an indirect-ref expression over the given TREE, which represents a
4359    piece of a va_arg() expansion.  */
4360 tree
4361 build_va_arg_indirect_ref (tree addr)
4362 {
4363   addr = build_simple_mem_ref_loc (EXPR_LOCATION (addr), addr);
4364
4365   if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF.  */
4366     mf_mark (addr);
4367
4368   return addr;
4369 }
4370
4371 /* Return a dummy expression of type TYPE in order to keep going after an
4372    error.  */
4373
4374 static tree
4375 dummy_object (tree type)
4376 {
4377   tree t = build_int_cst (build_pointer_type (type), 0);
4378   return build2 (MEM_REF, type, t, t);
4379 }
4380
4381 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4382    builtin function, but a very special sort of operator.  */
4383
4384 enum gimplify_status
4385 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4386 {
4387   tree promoted_type, have_va_type;
4388   tree valist = TREE_OPERAND (*expr_p, 0);
4389   tree type = TREE_TYPE (*expr_p);
4390   tree t;
4391   location_t loc = EXPR_LOCATION (*expr_p);
4392
4393   /* Verify that valist is of the proper type.  */
4394   have_va_type = TREE_TYPE (valist);
4395   if (have_va_type == error_mark_node)
4396     return GS_ERROR;
4397   have_va_type = targetm.canonical_va_list_type (have_va_type);
4398
4399   if (have_va_type == NULL_TREE)
4400     {
4401       error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4402       return GS_ERROR;
4403     }
4404
4405   /* Generate a diagnostic for requesting data of a type that cannot
4406      be passed through `...' due to type promotion at the call site.  */
4407   if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4408            != type)
4409     {
4410       static bool gave_help;
4411       bool warned;
4412
4413       /* Unfortunately, this is merely undefined, rather than a constraint
4414          violation, so we cannot make this an error.  If this call is never
4415          executed, the program is still strictly conforming.  */
4416       warned = warning_at (loc, 0,
4417                            "%qT is promoted to %qT when passed through %<...%>",
4418                            type, promoted_type);
4419       if (!gave_help && warned)
4420         {
4421           gave_help = true;
4422           inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4423                   promoted_type, type);
4424         }
4425
4426       /* We can, however, treat "undefined" any way we please.
4427          Call abort to encourage the user to fix the program.  */
4428       if (warned)
4429         inform (loc, "if this code is reached, the program will abort");
4430       /* Before the abort, allow the evaluation of the va_list
4431          expression to exit or longjmp.  */
4432       gimplify_and_add (valist, pre_p);
4433       t = build_call_expr_loc (loc,
4434                                builtin_decl_implicit (BUILT_IN_TRAP), 0);
4435       gimplify_and_add (t, pre_p);
4436
4437       /* This is dead code, but go ahead and finish so that the
4438          mode of the result comes out right.  */
4439       *expr_p = dummy_object (type);
4440       return GS_ALL_DONE;
4441     }
4442   else
4443     {
4444       /* Make it easier for the backends by protecting the valist argument
4445          from multiple evaluations.  */
4446       if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4447         {
4448           /* For this case, the backends will be expecting a pointer to
4449              TREE_TYPE (abi), but it's possible we've
4450              actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4451              So fix it.  */
4452           if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4453             {
4454               tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4455               valist = fold_convert_loc (loc, p1,
4456                                          build_fold_addr_expr_loc (loc, valist));
4457             }
4458
4459           gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4460         }
4461       else
4462         gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4463
4464       if (!targetm.gimplify_va_arg_expr)
4465         /* FIXME: Once most targets are converted we should merely
4466            assert this is non-null.  */
4467         return GS_ALL_DONE;
4468
4469       *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4470       return GS_OK;
4471     }
4472 }
4473
4474 /* Expand EXP, a call to __builtin_va_end.  */
4475
4476 static rtx
4477 expand_builtin_va_end (tree exp)
4478 {
4479   tree valist = CALL_EXPR_ARG (exp, 0);
4480
4481   /* Evaluate for side effects, if needed.  I hate macros that don't
4482      do that.  */
4483   if (TREE_SIDE_EFFECTS (valist))
4484     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4485
4486   return const0_rtx;
4487 }
4488
4489 /* Expand EXP, a call to __builtin_va_copy.  We do this as a
4490    builtin rather than just as an assignment in stdarg.h because of the
4491    nastiness of array-type va_list types.  */
4492
4493 static rtx
4494 expand_builtin_va_copy (tree exp)
4495 {
4496   tree dst, src, t;
4497   location_t loc = EXPR_LOCATION (exp);
4498
4499   dst = CALL_EXPR_ARG (exp, 0);
4500   src = CALL_EXPR_ARG (exp, 1);
4501
4502   dst = stabilize_va_list_loc (loc, dst, 1);
4503   src = stabilize_va_list_loc (loc, src, 0);
4504
4505   gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4506
4507   if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4508     {
4509       t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4510       TREE_SIDE_EFFECTS (t) = 1;
4511       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4512     }
4513   else
4514     {
4515       rtx dstb, srcb, size;
4516
4517       /* Evaluate to pointers.  */
4518       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4519       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4520       size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4521                   NULL_RTX, VOIDmode, EXPAND_NORMAL);
4522
4523       dstb = convert_memory_address (Pmode, dstb);
4524       srcb = convert_memory_address (Pmode, srcb);
4525
4526       /* "Dereference" to BLKmode memories.  */
4527       dstb = gen_rtx_MEM (BLKmode, dstb);
4528       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4529       set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4530       srcb = gen_rtx_MEM (BLKmode, srcb);
4531       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4532       set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4533
4534       /* Copy.  */
4535       emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4536     }
4537
4538   return const0_rtx;
4539 }
4540
4541 /* Expand a call to one of the builtin functions __builtin_frame_address or
4542    __builtin_return_address.  */
4543
4544 static rtx
4545 expand_builtin_frame_address (tree fndecl, tree exp)
4546 {
4547   /* The argument must be a nonnegative integer constant.
4548      It counts the number of frames to scan up the stack.
4549      The value is the return address saved in that frame.  */
4550   if (call_expr_nargs (exp) == 0)
4551     /* Warning about missing arg was already issued.  */
4552     return const0_rtx;
4553   else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4554     {
4555       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4556         error ("invalid argument to %<__builtin_frame_address%>");
4557       else
4558         error ("invalid argument to %<__builtin_return_address%>");
4559       return const0_rtx;
4560     }
4561   else
4562     {
4563       rtx tem
4564         = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4565                                       tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4566
4567       /* Some ports cannot access arbitrary stack frames.  */
4568       if (tem == NULL)
4569         {
4570           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4571             warning (0, "unsupported argument to %<__builtin_frame_address%>");
4572           else
4573             warning (0, "unsupported argument to %<__builtin_return_address%>");
4574           return const0_rtx;
4575         }
4576
4577       /* For __builtin_frame_address, return what we've got.  */
4578       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4579         return tem;
4580
4581       if (!REG_P (tem)
4582           && ! CONSTANT_P (tem))
4583         tem = copy_addr_to_reg (tem);
4584       return tem;
4585     }
4586 }
4587
4588 /* Expand EXP, a call to the alloca builtin.  Return NULL_RTX if we
4589    failed and the caller should emit a normal call.  CANNOT_ACCUMULATE
4590    is the same as for allocate_dynamic_stack_space.  */
4591
4592 static rtx
4593 expand_builtin_alloca (tree exp, bool cannot_accumulate)
4594 {
4595   rtx op0;
4596   rtx result;
4597   bool valid_arglist;
4598   unsigned int align;
4599   bool alloca_with_align = (DECL_FUNCTION_CODE (get_callee_fndecl (exp))
4600                             == BUILT_IN_ALLOCA_WITH_ALIGN);
4601
4602   /* Emit normal call if we use mudflap.  */
4603   if (flag_mudflap)
4604     return NULL_RTX;
4605
4606   valid_arglist
4607     = (alloca_with_align
4608        ? validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE)
4609        : validate_arglist (exp, INTEGER_TYPE, VOID_TYPE));
4610
4611   if (!valid_arglist)
4612     return NULL_RTX;
4613
4614   /* Compute the argument.  */
4615   op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4616
4617   /* Compute the alignment.  */
4618   align = (alloca_with_align
4619            ? TREE_INT_CST_LOW (CALL_EXPR_ARG (exp, 1))
4620            : BIGGEST_ALIGNMENT);
4621
4622   /* Allocate the desired space.  */
4623   result = allocate_dynamic_stack_space (op0, 0, align, cannot_accumulate);
4624   result = convert_memory_address (ptr_mode, result);
4625
4626   return result;
4627 }
4628
4629 /* Expand a call to bswap builtin in EXP.
4630    Return NULL_RTX if a normal call should be emitted rather than expanding the
4631    function in-line.  If convenient, the result should be placed in TARGET.
4632    SUBTARGET may be used as the target for computing one of EXP's operands.  */
4633
4634 static rtx
4635 expand_builtin_bswap (enum machine_mode target_mode, tree exp, rtx target,
4636                       rtx subtarget)
4637 {
4638   tree arg;
4639   rtx op0;
4640
4641   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4642     return NULL_RTX;
4643
4644   arg = CALL_EXPR_ARG (exp, 0);
4645   op0 = expand_expr (arg,
4646                      subtarget && GET_MODE (subtarget) == target_mode
4647                      ? subtarget : NULL_RTX,
4648                      target_mode, EXPAND_NORMAL);
4649   if (GET_MODE (op0) != target_mode)
4650     op0 = convert_to_mode (target_mode, op0, 1);
4651
4652   target = expand_unop (target_mode, bswap_optab, op0, target, 1);
4653
4654   gcc_assert (target);
4655
4656   return convert_to_mode (target_mode, target, 1);
4657 }
4658
4659 /* Expand a call to a unary builtin in EXP.
4660    Return NULL_RTX if a normal call should be emitted rather than expanding the
4661    function in-line.  If convenient, the result should be placed in TARGET.
4662    SUBTARGET may be used as the target for computing one of EXP's operands.  */
4663
4664 static rtx
4665 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
4666                      rtx subtarget, optab op_optab)
4667 {
4668   rtx op0;
4669
4670   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4671     return NULL_RTX;
4672
4673   /* Compute the argument.  */
4674   op0 = expand_expr (CALL_EXPR_ARG (exp, 0),
4675                      (subtarget
4676                       && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0)))
4677                           == GET_MODE (subtarget))) ? subtarget : NULL_RTX,
4678                      VOIDmode, EXPAND_NORMAL);
4679   /* Compute op, into TARGET if possible.
4680      Set TARGET to wherever the result comes back.  */
4681   target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
4682                         op_optab, op0, target, op_optab != clrsb_optab);
4683   gcc_assert (target);
4684
4685   return convert_to_mode (target_mode, target, 0);
4686 }
4687
4688 /* Expand a call to __builtin_expect.  We just return our argument
4689    as the builtin_expect semantic should've been already executed by
4690    tree branch prediction pass. */
4691
4692 static rtx
4693 expand_builtin_expect (tree exp, rtx target)
4694 {
4695   tree arg;
4696
4697   if (call_expr_nargs (exp) < 2)
4698     return const0_rtx;
4699   arg = CALL_EXPR_ARG (exp, 0);
4700
4701   target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4702   /* When guessing was done, the hints should be already stripped away.  */
4703   gcc_assert (!flag_guess_branch_prob
4704               || optimize == 0 || seen_error ());
4705   return target;
4706 }
4707
4708 /* Expand a call to __builtin_assume_aligned.  We just return our first
4709    argument as the builtin_assume_aligned semantic should've been already
4710    executed by CCP.  */
4711
4712 static rtx
4713 expand_builtin_assume_aligned (tree exp, rtx target)
4714 {
4715   if (call_expr_nargs (exp) < 2)
4716     return const0_rtx;
4717   target = expand_expr (CALL_EXPR_ARG (exp, 0), target, VOIDmode,
4718                         EXPAND_NORMAL);
4719   gcc_assert (!TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 1))
4720               && (call_expr_nargs (exp) < 3
4721                   || !TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 2))));
4722   return target;
4723 }
4724
4725 void
4726 expand_builtin_trap (void)
4727 {
4728 #ifdef HAVE_trap
4729   if (HAVE_trap)
4730     emit_insn (gen_trap ());
4731   else
4732 #endif
4733     emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4734   emit_barrier ();
4735 }
4736
4737 /* Expand a call to __builtin_unreachable.  We do nothing except emit
4738    a barrier saying that control flow will not pass here.
4739
4740    It is the responsibility of the program being compiled to ensure
4741    that control flow does never reach __builtin_unreachable.  */
4742 static void
4743 expand_builtin_unreachable (void)
4744 {
4745   emit_barrier ();
4746 }
4747
4748 /* Expand EXP, a call to fabs, fabsf or fabsl.
4749    Return NULL_RTX if a normal call should be emitted rather than expanding
4750    the function inline.  If convenient, the result should be placed
4751    in TARGET.  SUBTARGET may be used as the target for computing
4752    the operand.  */
4753
4754 static rtx
4755 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
4756 {
4757   enum machine_mode mode;
4758   tree arg;
4759   rtx op0;
4760
4761   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4762     return NULL_RTX;
4763
4764   arg = CALL_EXPR_ARG (exp, 0);
4765   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
4766   mode = TYPE_MODE (TREE_TYPE (arg));
4767   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4768   return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4769 }
4770
4771 /* Expand EXP, a call to copysign, copysignf, or copysignl.
4772    Return NULL is a normal call should be emitted rather than expanding the
4773    function inline.  If convenient, the result should be placed in TARGET.
4774    SUBTARGET may be used as the target for computing the operand.  */
4775
4776 static rtx
4777 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
4778 {
4779   rtx op0, op1;
4780   tree arg;
4781
4782   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
4783     return NULL_RTX;
4784
4785   arg = CALL_EXPR_ARG (exp, 0);
4786   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4787
4788   arg = CALL_EXPR_ARG (exp, 1);
4789   op1 = expand_normal (arg);
4790
4791   return expand_copysign (op0, op1, target);
4792 }
4793
4794 /* Create a new constant string literal and return a char* pointer to it.
4795    The STRING_CST value is the LEN characters at STR.  */
4796 tree
4797 build_string_literal (int len, const char *str)
4798 {
4799   tree t, elem, index, type;
4800
4801   t = build_string (len, str);
4802   elem = build_type_variant (char_type_node, 1, 0);
4803   index = build_index_type (size_int (len - 1));
4804   type = build_array_type (elem, index);
4805   TREE_TYPE (t) = type;
4806   TREE_CONSTANT (t) = 1;
4807   TREE_READONLY (t) = 1;
4808   TREE_STATIC (t) = 1;
4809
4810   type = build_pointer_type (elem);
4811   t = build1 (ADDR_EXPR, type,
4812               build4 (ARRAY_REF, elem,
4813                       t, integer_zero_node, NULL_TREE, NULL_TREE));
4814   return t;
4815 }
4816
4817 /* Expand a call to __builtin___clear_cache.  */
4818
4819 static rtx
4820 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
4821 {
4822 #ifndef HAVE_clear_cache
4823 #ifdef CLEAR_INSN_CACHE
4824   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4825      does something.  Just do the default expansion to a call to
4826      __clear_cache().  */
4827   return NULL_RTX;
4828 #else
4829   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4830      does nothing.  There is no need to call it.  Do nothing.  */
4831   return const0_rtx;
4832 #endif /* CLEAR_INSN_CACHE */
4833 #else
4834   /* We have a "clear_cache" insn, and it will handle everything.  */
4835   tree begin, end;
4836   rtx begin_rtx, end_rtx;
4837
4838   /* We must not expand to a library call.  If we did, any
4839      fallback library function in libgcc that might contain a call to
4840      __builtin___clear_cache() would recurse infinitely.  */
4841   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4842     {
4843       error ("both arguments to %<__builtin___clear_cache%> must be pointers");
4844       return const0_rtx;
4845     }
4846
4847   if (HAVE_clear_cache)
4848     {
4849       struct expand_operand ops[2];
4850
4851       begin = CALL_EXPR_ARG (exp, 0);
4852       begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
4853
4854       end = CALL_EXPR_ARG (exp, 1);
4855       end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
4856
4857       create_address_operand (&ops[0], begin_rtx);
4858       create_address_operand (&ops[1], end_rtx);
4859       if (maybe_expand_insn (CODE_FOR_clear_cache, 2, ops))
4860         return const0_rtx;
4861     }
4862   return const0_rtx;
4863 #endif /* HAVE_clear_cache */
4864 }
4865
4866 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT.  */
4867
4868 static rtx
4869 round_trampoline_addr (rtx tramp)
4870 {
4871   rtx temp, addend, mask;
4872
4873   /* If we don't need too much alignment, we'll have been guaranteed
4874      proper alignment by get_trampoline_type.  */
4875   if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
4876     return tramp;
4877
4878   /* Round address up to desired boundary.  */
4879   temp = gen_reg_rtx (Pmode);
4880   addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
4881   mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
4882
4883   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
4884                                temp, 0, OPTAB_LIB_WIDEN);
4885   tramp = expand_simple_binop (Pmode, AND, temp, mask,
4886                                temp, 0, OPTAB_LIB_WIDEN);
4887
4888   return tramp;
4889 }
4890
4891 static rtx
4892 expand_builtin_init_trampoline (tree exp, bool onstack)
4893 {
4894   tree t_tramp, t_func, t_chain;
4895   rtx m_tramp, r_tramp, r_chain, tmp;
4896
4897   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
4898                          POINTER_TYPE, VOID_TYPE))
4899     return NULL_RTX;
4900
4901   t_tramp = CALL_EXPR_ARG (exp, 0);
4902   t_func = CALL_EXPR_ARG (exp, 1);
4903   t_chain = CALL_EXPR_ARG (exp, 2);
4904
4905   r_tramp = expand_normal (t_tramp);
4906   m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
4907   MEM_NOTRAP_P (m_tramp) = 1;
4908
4909   /* If ONSTACK, the TRAMP argument should be the address of a field
4910      within the local function's FRAME decl.  Either way, let's see if
4911      we can fill in the MEM_ATTRs for this memory.  */
4912   if (TREE_CODE (t_tramp) == ADDR_EXPR)
4913     set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
4914                                      true, 0);
4915
4916   /* Creator of a heap trampoline is responsible for making sure the
4917      address is aligned to at least STACK_BOUNDARY.  Normally malloc
4918      will ensure this anyhow.  */
4919   tmp = round_trampoline_addr (r_tramp);
4920   if (tmp != r_tramp)
4921     {
4922       m_tramp = change_address (m_tramp, BLKmode, tmp);
4923       set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
4924       set_mem_size (m_tramp, TRAMPOLINE_SIZE);
4925     }
4926
4927   /* The FUNC argument should be the address of the nested function.
4928      Extract the actual function decl to pass to the hook.  */
4929   gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
4930   t_func = TREE_OPERAND (t_func, 0);
4931   gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
4932
4933   r_chain = expand_normal (t_chain);
4934
4935   /* Generate insns to initialize the trampoline.  */
4936   targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
4937
4938   if (onstack)
4939     {
4940       trampolines_created = 1;
4941
4942       warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
4943                   "trampoline generated for nested function %qD", t_func);
4944     }
4945
4946   return const0_rtx;
4947 }
4948
4949 static rtx
4950 expand_builtin_adjust_trampoline (tree exp)
4951 {
4952   rtx tramp;
4953
4954   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
4955     return NULL_RTX;
4956
4957   tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
4958   tramp = round_trampoline_addr (tramp);
4959   if (targetm.calls.trampoline_adjust_address)
4960     tramp = targetm.calls.trampoline_adjust_address (tramp);
4961
4962   return tramp;
4963 }
4964
4965 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
4966    function.  The function first checks whether the back end provides
4967    an insn to implement signbit for the respective mode.  If not, it
4968    checks whether the floating point format of the value is such that
4969    the sign bit can be extracted.  If that is not the case, the
4970    function returns NULL_RTX to indicate that a normal call should be
4971    emitted rather than expanding the function in-line.  EXP is the
4972    expression that is a call to the builtin function; if convenient,
4973    the result should be placed in TARGET.  */
4974 static rtx
4975 expand_builtin_signbit (tree exp, rtx target)
4976 {
4977   const struct real_format *fmt;
4978   enum machine_mode fmode, imode, rmode;
4979   tree arg;
4980   int word, bitpos;
4981   enum insn_code icode;
4982   rtx temp;
4983   location_t loc = EXPR_LOCATION (exp);
4984
4985   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4986     return NULL_RTX;
4987
4988   arg = CALL_EXPR_ARG (exp, 0);
4989   fmode = TYPE_MODE (TREE_TYPE (arg));
4990   rmode = TYPE_MODE (TREE_TYPE (exp));
4991   fmt = REAL_MODE_FORMAT (fmode);
4992
4993   arg = builtin_save_expr (arg);
4994
4995   /* Expand the argument yielding a RTX expression. */
4996   temp = expand_normal (arg);
4997
4998   /* Check if the back end provides an insn that handles signbit for the
4999      argument's mode. */
5000   icode = optab_handler (signbit_optab, fmode);
5001   if (icode != CODE_FOR_nothing)
5002     {
5003       rtx last = get_last_insn ();
5004       target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5005       if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
5006         return target;
5007       delete_insns_since (last);
5008     }
5009
5010   /* For floating point formats without a sign bit, implement signbit
5011      as "ARG < 0.0".  */
5012   bitpos = fmt->signbit_ro;
5013   if (bitpos < 0)
5014   {
5015     /* But we can't do this if the format supports signed zero.  */
5016     if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5017       return NULL_RTX;
5018
5019     arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5020                        build_real (TREE_TYPE (arg), dconst0));
5021     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5022   }
5023
5024   if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5025     {
5026       imode = int_mode_for_mode (fmode);
5027       if (imode == BLKmode)
5028         return NULL_RTX;
5029       temp = gen_lowpart (imode, temp);
5030     }
5031   else
5032     {
5033       imode = word_mode;
5034       /* Handle targets with different FP word orders.  */
5035       if (FLOAT_WORDS_BIG_ENDIAN)
5036         word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5037       else
5038         word = bitpos / BITS_PER_WORD;
5039       temp = operand_subword_force (temp, word, fmode);
5040       bitpos = bitpos % BITS_PER_WORD;
5041     }
5042
5043   /* Force the intermediate word_mode (or narrower) result into a
5044      register.  This avoids attempting to create paradoxical SUBREGs
5045      of floating point modes below.  */
5046   temp = force_reg (imode, temp);
5047
5048   /* If the bitpos is within the "result mode" lowpart, the operation
5049      can be implement with a single bitwise AND.  Otherwise, we need
5050      a right shift and an AND.  */
5051
5052   if (bitpos < GET_MODE_BITSIZE (rmode))
5053     {
5054       double_int mask = double_int_setbit (double_int_zero, bitpos);
5055
5056       if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5057         temp = gen_lowpart (rmode, temp);
5058       temp = expand_binop (rmode, and_optab, temp,
5059                            immed_double_int_const (mask, rmode),
5060                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5061     }
5062   else
5063     {
5064       /* Perform a logical right shift to place the signbit in the least
5065          significant bit, then truncate the result to the desired mode
5066          and mask just this bit.  */
5067       temp = expand_shift (RSHIFT_EXPR, imode, temp, bitpos, NULL_RTX, 1);
5068       temp = gen_lowpart (rmode, temp);
5069       temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5070                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5071     }
5072
5073   return temp;
5074 }
5075
5076 /* Expand fork or exec calls.  TARGET is the desired target of the
5077    call.  EXP is the call. FN is the
5078    identificator of the actual function.  IGNORE is nonzero if the
5079    value is to be ignored.  */
5080
5081 static rtx
5082 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5083 {
5084   tree id, decl;
5085   tree call;
5086
5087   /* If we are not profiling, just call the function.  */
5088   if (!profile_arc_flag)
5089     return NULL_RTX;
5090
5091   /* Otherwise call the wrapper.  This should be equivalent for the rest of
5092      compiler, so the code does not diverge, and the wrapper may run the
5093      code necessary for keeping the profiling sane.  */
5094
5095   switch (DECL_FUNCTION_CODE (fn))
5096     {
5097     case BUILT_IN_FORK:
5098       id = get_identifier ("__gcov_fork");
5099       break;
5100
5101     case BUILT_IN_EXECL:
5102       id = get_identifier ("__gcov_execl");
5103       break;
5104
5105     case BUILT_IN_EXECV:
5106       id = get_identifier ("__gcov_execv");
5107       break;
5108
5109     case BUILT_IN_EXECLP:
5110       id = get_identifier ("__gcov_execlp");
5111       break;
5112
5113     case BUILT_IN_EXECLE:
5114       id = get_identifier ("__gcov_execle");
5115       break;
5116
5117     case BUILT_IN_EXECVP:
5118       id = get_identifier ("__gcov_execvp");
5119       break;
5120
5121     case BUILT_IN_EXECVE:
5122       id = get_identifier ("__gcov_execve");
5123       break;
5124
5125     default:
5126       gcc_unreachable ();
5127     }
5128
5129   decl = build_decl (DECL_SOURCE_LOCATION (fn),
5130                      FUNCTION_DECL, id, TREE_TYPE (fn));
5131   DECL_EXTERNAL (decl) = 1;
5132   TREE_PUBLIC (decl) = 1;
5133   DECL_ARTIFICIAL (decl) = 1;
5134   TREE_NOTHROW (decl) = 1;
5135   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5136   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5137   call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5138   return expand_call (call, target, ignore);
5139  }
5140
5141
5142 \f
5143 /* Reconstitute a mode for a __sync intrinsic operation.  Since the type of
5144    the pointer in these functions is void*, the tree optimizers may remove
5145    casts.  The mode computed in expand_builtin isn't reliable either, due
5146    to __sync_bool_compare_and_swap.
5147
5148    FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5149    group of builtins.  This gives us log2 of the mode size.  */
5150
5151 static inline enum machine_mode
5152 get_builtin_sync_mode (int fcode_diff)
5153 {
5154   /* The size is not negotiable, so ask not to get BLKmode in return
5155      if the target indicates that a smaller size would be better.  */
5156   return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5157 }
5158
5159 /* Expand the memory expression LOC and return the appropriate memory operand
5160    for the builtin_sync operations.  */
5161
5162 static rtx
5163 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5164 {
5165   rtx addr, mem;
5166
5167   addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
5168   addr = convert_memory_address (Pmode, addr);
5169
5170   /* Note that we explicitly do not want any alias information for this
5171      memory, so that we kill all other live memories.  Otherwise we don't
5172      satisfy the full barrier semantics of the intrinsic.  */
5173   mem = validize_mem (gen_rtx_MEM (mode, addr));
5174
5175   /* The alignment needs to be at least according to that of the mode.  */
5176   set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
5177                            get_pointer_alignment (loc)));
5178   set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5179   MEM_VOLATILE_P (mem) = 1;
5180
5181   return mem;
5182 }
5183
5184 /* Make sure an argument is in the right mode.
5185    EXP is the tree argument.
5186    MODE is the mode it should be in.  */
5187
5188 static rtx
5189 expand_expr_force_mode (tree exp, enum machine_mode mode)
5190 {
5191   rtx val;
5192   enum machine_mode old_mode;
5193
5194   val = expand_expr (exp, NULL_RTX, mode, EXPAND_NORMAL);
5195   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5196      of CONST_INTs, where we know the old_mode only from the call argument.  */
5197
5198   old_mode = GET_MODE (val);
5199   if (old_mode == VOIDmode)
5200     old_mode = TYPE_MODE (TREE_TYPE (exp));
5201   val = convert_modes (mode, old_mode, val, 1);
5202   return val;
5203 }
5204
5205
5206 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5207    EXP is the CALL_EXPR.  CODE is the rtx code
5208    that corresponds to the arithmetic or logical operation from the name;
5209    an exception here is that NOT actually means NAND.  TARGET is an optional
5210    place for us to store the results; AFTER is true if this is the
5211    fetch_and_xxx form.  */
5212
5213 static rtx
5214 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5215                                enum rtx_code code, bool after,
5216                                rtx target)
5217 {
5218   rtx val, mem;
5219   location_t loc = EXPR_LOCATION (exp);
5220
5221   if (code == NOT && warn_sync_nand)
5222     {
5223       tree fndecl = get_callee_fndecl (exp);
5224       enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5225
5226       static bool warned_f_a_n, warned_n_a_f;
5227
5228       switch (fcode)
5229         {
5230         case BUILT_IN_SYNC_FETCH_AND_NAND_1:
5231         case BUILT_IN_SYNC_FETCH_AND_NAND_2:
5232         case BUILT_IN_SYNC_FETCH_AND_NAND_4:
5233         case BUILT_IN_SYNC_FETCH_AND_NAND_8:
5234         case BUILT_IN_SYNC_FETCH_AND_NAND_16:
5235           if (warned_f_a_n)
5236             break;
5237
5238           fndecl = builtin_decl_implicit (BUILT_IN_SYNC_FETCH_AND_NAND_N);
5239           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5240           warned_f_a_n = true;
5241           break;
5242
5243         case BUILT_IN_SYNC_NAND_AND_FETCH_1:
5244         case BUILT_IN_SYNC_NAND_AND_FETCH_2:
5245         case BUILT_IN_SYNC_NAND_AND_FETCH_4:
5246         case BUILT_IN_SYNC_NAND_AND_FETCH_8:
5247         case BUILT_IN_SYNC_NAND_AND_FETCH_16:
5248           if (warned_n_a_f)
5249             break;
5250
5251          fndecl = builtin_decl_implicit (BUILT_IN_SYNC_NAND_AND_FETCH_N);
5252           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5253           warned_n_a_f = true;
5254           break;
5255
5256         default:
5257           gcc_unreachable ();
5258         }
5259     }
5260
5261   /* Expand the operands.  */
5262   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5263   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5264
5265   return expand_atomic_fetch_op (target, mem, val, code, MEMMODEL_SEQ_CST,
5266                                  after);
5267 }
5268
5269 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5270    intrinsics. EXP is the CALL_EXPR.  IS_BOOL is
5271    true if this is the boolean form.  TARGET is a place for us to store the
5272    results; this is NOT optional if IS_BOOL is true.  */
5273
5274 static rtx
5275 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5276                                  bool is_bool, rtx target)
5277 {
5278   rtx old_val, new_val, mem;
5279   rtx *pbool, *poval;
5280
5281   /* Expand the operands.  */
5282   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5283   old_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5284   new_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode);
5285
5286   pbool = poval = NULL;
5287   if (target != const0_rtx)
5288     {
5289       if (is_bool)
5290         pbool = &target;
5291       else
5292         poval = &target;
5293     }
5294   if (!expand_atomic_compare_and_swap (pbool, poval, mem, old_val, new_val,
5295                                        false, MEMMODEL_SEQ_CST,
5296                                        MEMMODEL_SEQ_CST))
5297     return NULL_RTX;
5298
5299   return target;
5300 }
5301
5302 /* Expand the __sync_lock_test_and_set intrinsic.  Note that the most
5303    general form is actually an atomic exchange, and some targets only
5304    support a reduced form with the second argument being a constant 1.
5305    EXP is the CALL_EXPR; TARGET is an optional place for us to store
5306    the results.  */
5307
5308 static rtx
5309 expand_builtin_sync_lock_test_and_set (enum machine_mode mode, tree exp,
5310                                        rtx target)
5311 {
5312   rtx val, mem;
5313
5314   /* Expand the operands.  */
5315   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5316   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5317
5318   return expand_sync_lock_test_and_set (target, mem, val);
5319 }
5320
5321 /* Expand the __sync_lock_release intrinsic.  EXP is the CALL_EXPR.  */
5322
5323 static void
5324 expand_builtin_sync_lock_release (enum machine_mode mode, tree exp)
5325 {
5326   rtx mem;
5327
5328   /* Expand the operands.  */
5329   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5330
5331   expand_atomic_store (mem, const0_rtx, MEMMODEL_RELEASE, true);
5332 }
5333
5334 /* Given an integer representing an ``enum memmodel'', verify its
5335    correctness and return the memory model enum.  */
5336
5337 static enum memmodel
5338 get_memmodel (tree exp)
5339 {
5340   rtx op;
5341
5342   /* If the parameter is not a constant, it's a run time value so we'll just
5343      convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking.  */
5344   if (TREE_CODE (exp) != INTEGER_CST)
5345     return MEMMODEL_SEQ_CST;
5346
5347   op = expand_normal (exp);
5348   if (INTVAL (op) < 0 || INTVAL (op) >= MEMMODEL_LAST)
5349     {
5350       warning (OPT_Winvalid_memory_model,
5351                "invalid memory model argument to builtin");
5352       return MEMMODEL_SEQ_CST;
5353     }
5354   return (enum memmodel) INTVAL (op);
5355 }
5356
5357 /* Expand the __atomic_exchange intrinsic:
5358         TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel)
5359    EXP is the CALL_EXPR.
5360    TARGET is an optional place for us to store the results.  */
5361
5362 static rtx
5363 expand_builtin_atomic_exchange (enum machine_mode mode, tree exp, rtx target)
5364 {
5365   rtx val, mem;
5366   enum memmodel model;
5367
5368   model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5369   if (model == MEMMODEL_CONSUME)
5370     {
5371       error ("invalid memory model for %<__atomic_exchange%>");
5372       return NULL_RTX;
5373     }
5374
5375   if (!flag_inline_atomics)
5376     return NULL_RTX;
5377
5378   /* Expand the operands.  */
5379   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5380   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5381
5382   return expand_atomic_exchange (target, mem, val, model);
5383 }
5384
5385 /* Expand the __atomic_compare_exchange intrinsic:
5386         bool __atomic_compare_exchange (TYPE *object, TYPE *expect,
5387                                         TYPE desired, BOOL weak,
5388                                         enum memmodel success,
5389                                         enum memmodel failure)
5390    EXP is the CALL_EXPR.
5391    TARGET is an optional place for us to store the results.  */
5392
5393 static rtx
5394 expand_builtin_atomic_compare_exchange (enum machine_mode mode, tree exp,
5395                                         rtx target)
5396 {
5397   rtx expect, desired, mem, oldval;
5398   enum memmodel success, failure;
5399   tree weak;
5400   bool is_weak;
5401
5402   success = get_memmodel (CALL_EXPR_ARG (exp, 4));
5403   failure = get_memmodel (CALL_EXPR_ARG (exp, 5));
5404
5405   if (failure == MEMMODEL_RELEASE || failure == MEMMODEL_ACQ_REL)
5406     {
5407       error ("invalid failure memory model for %<__atomic_compare_exchange%>");
5408       return NULL_RTX;
5409     }
5410
5411   if (failure > success)
5412     {
5413       error ("failure memory model cannot be stronger than success "
5414              "memory model for %<__atomic_compare_exchange%>");
5415       return NULL_RTX;
5416     }
5417
5418   if (!flag_inline_atomics)
5419     return NULL_RTX;
5420
5421   /* Expand the operands.  */
5422   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5423
5424   expect = expand_normal (CALL_EXPR_ARG (exp, 1));
5425   expect = convert_memory_address (Pmode, expect);
5426   desired = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode);
5427
5428   weak = CALL_EXPR_ARG (exp, 3);
5429   is_weak = false;
5430   if (host_integerp (weak, 0) && tree_low_cst (weak, 0) != 0)
5431     is_weak = true;
5432
5433   oldval = copy_to_reg (gen_rtx_MEM (mode, expect));
5434
5435   if (!expand_atomic_compare_and_swap ((target == const0_rtx ? NULL : &target),
5436                                        &oldval, mem, oldval, desired,
5437                                        is_weak, success, failure))
5438     return NULL_RTX;
5439
5440   emit_move_insn (gen_rtx_MEM (mode, expect), oldval);
5441   return target;
5442 }
5443
5444 /* Expand the __atomic_load intrinsic:
5445         TYPE __atomic_load (TYPE *object, enum memmodel)
5446    EXP is the CALL_EXPR.
5447    TARGET is an optional place for us to store the results.  */
5448
5449 static rtx
5450 expand_builtin_atomic_load (enum machine_mode mode, tree exp, rtx target)
5451 {
5452   rtx mem;
5453   enum memmodel model;
5454
5455   model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5456   if (model == MEMMODEL_RELEASE
5457       || model == MEMMODEL_ACQ_REL)
5458     {
5459       error ("invalid memory model for %<__atomic_load%>");
5460       return NULL_RTX;
5461     }
5462
5463   if (!flag_inline_atomics)
5464     return NULL_RTX;
5465
5466   /* Expand the operand.  */
5467   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5468
5469   return expand_atomic_load (target, mem, model);
5470 }
5471
5472
5473 /* Expand the __atomic_store intrinsic:
5474         void __atomic_store (TYPE *object, TYPE desired, enum memmodel)
5475    EXP is the CALL_EXPR.
5476    TARGET is an optional place for us to store the results.  */
5477
5478 static rtx
5479 expand_builtin_atomic_store (enum machine_mode mode, tree exp)
5480 {
5481   rtx mem, val;
5482   enum memmodel model;
5483
5484   model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5485   if (model != MEMMODEL_RELAXED
5486       && model != MEMMODEL_SEQ_CST
5487       && model != MEMMODEL_RELEASE)
5488     {
5489       error ("invalid memory model for %<__atomic_store%>");
5490       return NULL_RTX;
5491     }
5492
5493   if (!flag_inline_atomics)
5494     return NULL_RTX;
5495
5496   /* Expand the operands.  */
5497   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5498   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5499
5500   return expand_atomic_store (mem, val, model, false);
5501 }
5502
5503 /* Expand the __atomic_fetch_XXX intrinsic:
5504         TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel)
5505    EXP is the CALL_EXPR.
5506    TARGET is an optional place for us to store the results.
5507    CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR.
5508    FETCH_AFTER is true if returning the result of the operation.
5509    FETCH_AFTER is false if returning the value before the operation.
5510    IGNORE is true if the result is not used.
5511    EXT_CALL is the correct builtin for an external call if this cannot be
5512    resolved to an instruction sequence.  */
5513
5514 static rtx
5515 expand_builtin_atomic_fetch_op (enum machine_mode mode, tree exp, rtx target,
5516                                 enum rtx_code code, bool fetch_after,
5517                                 bool ignore, enum built_in_function ext_call)
5518 {
5519   rtx val, mem, ret;
5520   enum memmodel model;
5521   tree fndecl;
5522   tree addr;
5523
5524   model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5525
5526   /* Expand the operands.  */
5527   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5528   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5529
5530   /* Only try generating instructions if inlining is turned on.  */
5531   if (flag_inline_atomics)
5532     {
5533       ret = expand_atomic_fetch_op (target, mem, val, code, model, fetch_after);
5534       if (ret)
5535         return ret;
5536     }
5537
5538   /* Return if a different routine isn't needed for the library call.  */
5539   if (ext_call == BUILT_IN_NONE)
5540     return NULL_RTX;
5541
5542   /* Change the call to the specified function.  */
5543   fndecl = get_callee_fndecl (exp);
5544   addr = CALL_EXPR_FN (exp);
5545   STRIP_NOPS (addr);
5546
5547   gcc_assert (TREE_OPERAND (addr, 0) == fndecl);
5548   TREE_OPERAND (addr, 0) = builtin_decl_explicit(ext_call);
5549
5550   /* Expand the call here so we can emit trailing code.  */
5551   ret = expand_call (exp, target, ignore);
5552
5553   /* Replace the original function just in case it matters.  */
5554   TREE_OPERAND (addr, 0) = fndecl;
5555
5556   /* Then issue the arithmetic correction to return the right result.  */
5557   if (!ignore)
5558     {
5559       if (code == NOT)
5560         {
5561           ret = expand_simple_binop (mode, AND, ret, val, NULL_RTX, true,
5562                                      OPTAB_LIB_WIDEN);
5563           ret = expand_simple_unop (mode, NOT, ret, target, true);
5564         }
5565       else
5566         ret = expand_simple_binop (mode, code, ret, val, target, true,
5567                                    OPTAB_LIB_WIDEN);
5568     }
5569   return ret;
5570 }
5571
5572
5573 #ifndef HAVE_atomic_clear
5574 # define HAVE_atomic_clear 0
5575 # define gen_atomic_clear(x,y) (gcc_unreachable (), NULL_RTX)
5576 #endif
5577
5578 /* Expand an atomic clear operation.
5579         void _atomic_clear (BOOL *obj, enum memmodel)
5580    EXP is the call expression.  */
5581
5582 static rtx
5583 expand_builtin_atomic_clear (tree exp)
5584 {
5585   enum machine_mode mode;
5586   rtx mem, ret;
5587   enum memmodel model;
5588
5589   mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0);
5590   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5591   model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5592
5593   if (model == MEMMODEL_ACQUIRE || model == MEMMODEL_ACQ_REL)
5594     {
5595       error ("invalid memory model for %<__atomic_store%>");
5596       return const0_rtx;
5597     }
5598
5599   if (HAVE_atomic_clear)
5600     {
5601       emit_insn (gen_atomic_clear (mem, model));
5602       return const0_rtx;
5603     }
5604
5605   /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release.
5606      Failing that, a store is issued by __atomic_store.  The only way this can
5607      fail is if the bool type is larger than a word size.  Unlikely, but
5608      handle it anyway for completeness.  Assume a single threaded model since
5609      there is no atomic support in this case, and no barriers are required.  */
5610   ret = expand_atomic_store (mem, const0_rtx, model, true);
5611   if (!ret)
5612     emit_move_insn (mem, const0_rtx);
5613   return const0_rtx;
5614 }
5615
5616 /* Expand an atomic test_and_set operation.
5617         bool _atomic_test_and_set (BOOL *obj, enum memmodel)
5618    EXP is the call expression.  */
5619
5620 static rtx
5621 expand_builtin_atomic_test_and_set (tree exp, rtx target)
5622 {
5623   rtx mem;
5624   enum memmodel model;
5625   enum machine_mode mode;
5626
5627   mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0);
5628   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5629   model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5630
5631   return expand_atomic_test_and_set (target, mem, model);
5632 }
5633
5634
5635 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on
5636    this architecture.  If ARG1 is NULL, use typical alignment for size ARG0.  */
5637
5638 static tree
5639 fold_builtin_atomic_always_lock_free (tree arg0, tree arg1)
5640 {
5641   int size;
5642   enum machine_mode mode;
5643   unsigned int mode_align, type_align;
5644
5645   if (TREE_CODE (arg0) != INTEGER_CST)
5646     return NULL_TREE;
5647
5648   size = INTVAL (expand_normal (arg0)) * BITS_PER_UNIT;
5649   mode = mode_for_size (size, MODE_INT, 0);
5650   mode_align = GET_MODE_ALIGNMENT (mode);
5651
5652   if (TREE_CODE (arg1) == INTEGER_CST && INTVAL (expand_normal (arg1)) == 0)
5653     type_align = mode_align;
5654   else
5655     {
5656       tree ttype = TREE_TYPE (arg1);
5657
5658       /* This function is usually invoked and folded immediately by the front
5659          end before anything else has a chance to look at it.  The pointer
5660          parameter at this point is usually cast to a void *, so check for that
5661          and look past the cast.  */
5662       if (TREE_CODE (arg1) == NOP_EXPR && POINTER_TYPE_P (ttype)
5663           && VOID_TYPE_P (TREE_TYPE (ttype)))
5664         arg1 = TREE_OPERAND (arg1, 0);
5665
5666       ttype = TREE_TYPE (arg1);
5667       gcc_assert (POINTER_TYPE_P (ttype));
5668
5669       /* Get the underlying type of the object.  */
5670       ttype = TREE_TYPE (ttype);
5671       type_align = TYPE_ALIGN (ttype);
5672     }
5673
5674   /* If the object has smaller alignment, the the lock free routines cannot
5675      be used.  */
5676   if (type_align < mode_align)
5677     return boolean_false_node;
5678
5679   /* Check if a compare_and_swap pattern exists for the mode which represents
5680      the required size.  The pattern is not allowed to fail, so the existence
5681      of the pattern indicates support is present.  */
5682   if (can_compare_and_swap_p (mode, true))
5683     return boolean_true_node;
5684   else
5685     return boolean_false_node;
5686 }
5687
5688 /* Return true if the parameters to call EXP represent an object which will
5689    always generate lock free instructions.  The first argument represents the
5690    size of the object, and the second parameter is a pointer to the object
5691    itself.  If NULL is passed for the object, then the result is based on
5692    typical alignment for an object of the specified size.  Otherwise return
5693    false.  */
5694
5695 static rtx
5696 expand_builtin_atomic_always_lock_free (tree exp)
5697 {
5698   tree size;
5699   tree arg0 = CALL_EXPR_ARG (exp, 0);
5700   tree arg1 = CALL_EXPR_ARG (exp, 1);
5701
5702   if (TREE_CODE (arg0) != INTEGER_CST)
5703     {
5704       error ("non-constant argument 1 to __atomic_always_lock_free");
5705       return const0_rtx;
5706     }
5707
5708   size = fold_builtin_atomic_always_lock_free (arg0, arg1);
5709   if (size == boolean_true_node)
5710     return const1_rtx;
5711   return const0_rtx;
5712 }
5713
5714 /* Return a one or zero if it can be determined that object ARG1 of size ARG
5715    is lock free on this architecture.  */
5716
5717 static tree
5718 fold_builtin_atomic_is_lock_free (tree arg0, tree arg1)
5719 {
5720   if (!flag_inline_atomics)
5721     return NULL_TREE;
5722
5723   /* If it isn't always lock free, don't generate a result.  */
5724   if (fold_builtin_atomic_always_lock_free (arg0, arg1) == boolean_true_node)
5725     return boolean_true_node;
5726
5727   return NULL_TREE;
5728 }
5729
5730 /* Return true if the parameters to call EXP represent an object which will
5731    always generate lock free instructions.  The first argument represents the
5732    size of the object, and the second parameter is a pointer to the object
5733    itself.  If NULL is passed for the object, then the result is based on
5734    typical alignment for an object of the specified size.  Otherwise return
5735    NULL*/
5736
5737 static rtx
5738 expand_builtin_atomic_is_lock_free (tree exp)
5739 {
5740   tree size;
5741   tree arg0 = CALL_EXPR_ARG (exp, 0);
5742   tree arg1 = CALL_EXPR_ARG (exp, 1);
5743
5744   if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
5745     {
5746       error ("non-integer argument 1 to __atomic_is_lock_free");
5747       return NULL_RTX;
5748     }
5749
5750   if (!flag_inline_atomics)
5751     return NULL_RTX;
5752
5753   /* If the value is known at compile time, return the RTX for it.  */
5754   size = fold_builtin_atomic_is_lock_free (arg0, arg1);
5755   if (size == boolean_true_node)
5756     return const1_rtx;
5757
5758   return NULL_RTX;
5759 }
5760
5761 /* Expand the __atomic_thread_fence intrinsic:
5762         void __atomic_thread_fence (enum memmodel)
5763    EXP is the CALL_EXPR.  */
5764
5765 static void
5766 expand_builtin_atomic_thread_fence (tree exp)
5767 {
5768   enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0));
5769   expand_mem_thread_fence (model);
5770 }
5771
5772 /* Expand the __atomic_signal_fence intrinsic:
5773         void __atomic_signal_fence (enum memmodel)
5774    EXP is the CALL_EXPR.  */
5775
5776 static void
5777 expand_builtin_atomic_signal_fence (tree exp)
5778 {
5779   enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0));
5780   expand_mem_signal_fence (model);
5781 }
5782
5783 /* Expand the __sync_synchronize intrinsic.  */
5784
5785 static void
5786 expand_builtin_sync_synchronize (void)
5787 {
5788   expand_mem_thread_fence (MEMMODEL_SEQ_CST);
5789 }
5790
5791 \f
5792 /* Expand an expression EXP that calls a built-in function,
5793    with result going to TARGET if that's convenient
5794    (and in mode MODE if that's convenient).
5795    SUBTARGET may be used as the target for computing one of EXP's operands.
5796    IGNORE is nonzero if the value is to be ignored.  */
5797
5798 rtx
5799 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5800                 int ignore)
5801 {
5802   tree fndecl = get_callee_fndecl (exp);
5803   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5804   enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5805   int flags;
5806
5807   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5808     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5809
5810   /* When not optimizing, generate calls to library functions for a certain
5811      set of builtins.  */
5812   if (!optimize
5813       && !called_as_built_in (fndecl)
5814       && fcode != BUILT_IN_ALLOCA
5815       && fcode != BUILT_IN_ALLOCA_WITH_ALIGN
5816       && fcode != BUILT_IN_FREE)
5817     return expand_call (exp, target, ignore);
5818
5819   /* The built-in function expanders test for target == const0_rtx
5820      to determine whether the function's result will be ignored.  */
5821   if (ignore)
5822     target = const0_rtx;
5823
5824   /* If the result of a pure or const built-in function is ignored, and
5825      none of its arguments are volatile, we can avoid expanding the
5826      built-in call and just evaluate the arguments for side-effects.  */
5827   if (target == const0_rtx
5828       && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5829       && !(flags & ECF_LOOPING_CONST_OR_PURE))
5830     {
5831       bool volatilep = false;
5832       tree arg;
5833       call_expr_arg_iterator iter;
5834
5835       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5836         if (TREE_THIS_VOLATILE (arg))
5837           {
5838             volatilep = true;
5839             break;
5840           }
5841
5842       if (! volatilep)
5843         {
5844           FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5845             expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5846           return const0_rtx;
5847         }
5848     }
5849
5850   switch (fcode)
5851     {
5852     CASE_FLT_FN (BUILT_IN_FABS):
5853       target = expand_builtin_fabs (exp, target, subtarget);
5854       if (target)
5855         return target;
5856       break;
5857
5858     CASE_FLT_FN (BUILT_IN_COPYSIGN):
5859       target = expand_builtin_copysign (exp, target, subtarget);
5860       if (target)
5861         return target;
5862       break;
5863
5864       /* Just do a normal library call if we were unable to fold
5865          the values.  */
5866     CASE_FLT_FN (BUILT_IN_CABS):
5867       break;
5868
5869     CASE_FLT_FN (BUILT_IN_EXP):
5870     CASE_FLT_FN (BUILT_IN_EXP10):
5871     CASE_FLT_FN (BUILT_IN_POW10):
5872     CASE_FLT_FN (BUILT_IN_EXP2):
5873     CASE_FLT_FN (BUILT_IN_EXPM1):
5874     CASE_FLT_FN (BUILT_IN_LOGB):
5875     CASE_FLT_FN (BUILT_IN_LOG):
5876     CASE_FLT_FN (BUILT_IN_LOG10):
5877     CASE_FLT_FN (BUILT_IN_LOG2):
5878     CASE_FLT_FN (BUILT_IN_LOG1P):
5879     CASE_FLT_FN (BUILT_IN_TAN):
5880     CASE_FLT_FN (BUILT_IN_ASIN):
5881     CASE_FLT_FN (BUILT_IN_ACOS):
5882     CASE_FLT_FN (BUILT_IN_ATAN):
5883     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5884       /* Treat these like sqrt only if unsafe math optimizations are allowed,
5885          because of possible accuracy problems.  */
5886       if (! flag_unsafe_math_optimizations)
5887         break;
5888     CASE_FLT_FN (BUILT_IN_SQRT):
5889     CASE_FLT_FN (BUILT_IN_FLOOR):
5890     CASE_FLT_FN (BUILT_IN_CEIL):
5891     CASE_FLT_FN (BUILT_IN_TRUNC):
5892     CASE_FLT_FN (BUILT_IN_ROUND):
5893     CASE_FLT_FN (BUILT_IN_NEARBYINT):
5894     CASE_FLT_FN (BUILT_IN_RINT):
5895       target = expand_builtin_mathfn (exp, target, subtarget);
5896       if (target)
5897         return target;
5898       break;
5899
5900     CASE_FLT_FN (BUILT_IN_FMA):
5901       target = expand_builtin_mathfn_ternary (exp, target, subtarget);
5902       if (target)
5903         return target;
5904       break;
5905
5906     CASE_FLT_FN (BUILT_IN_ILOGB):
5907       if (! flag_unsafe_math_optimizations)
5908         break;
5909     CASE_FLT_FN (BUILT_IN_ISINF):
5910     CASE_FLT_FN (BUILT_IN_FINITE):
5911     case BUILT_IN_ISFINITE:
5912     case BUILT_IN_ISNORMAL:
5913       target = expand_builtin_interclass_mathfn (exp, target);
5914       if (target)
5915         return target;
5916       break;
5917
5918     CASE_FLT_FN (BUILT_IN_ICEIL):
5919     CASE_FLT_FN (BUILT_IN_LCEIL):
5920     CASE_FLT_FN (BUILT_IN_LLCEIL):
5921     CASE_FLT_FN (BUILT_IN_LFLOOR):
5922     CASE_FLT_FN (BUILT_IN_IFLOOR):
5923     CASE_FLT_FN (BUILT_IN_LLFLOOR):
5924       target = expand_builtin_int_roundingfn (exp, target);
5925       if (target)
5926         return target;
5927       break;
5928
5929     CASE_FLT_FN (BUILT_IN_IRINT):
5930     CASE_FLT_FN (BUILT_IN_LRINT):
5931     CASE_FLT_FN (BUILT_IN_LLRINT):
5932     CASE_FLT_FN (BUILT_IN_IROUND):
5933     CASE_FLT_FN (BUILT_IN_LROUND):
5934     CASE_FLT_FN (BUILT_IN_LLROUND):
5935       target = expand_builtin_int_roundingfn_2 (exp, target);
5936       if (target)
5937         return target;
5938       break;
5939
5940     CASE_FLT_FN (BUILT_IN_POWI):
5941       target = expand_builtin_powi (exp, target);
5942       if (target)
5943         return target;
5944       break;
5945
5946     CASE_FLT_FN (BUILT_IN_ATAN2):
5947     CASE_FLT_FN (BUILT_IN_LDEXP):
5948     CASE_FLT_FN (BUILT_IN_SCALB):
5949     CASE_FLT_FN (BUILT_IN_SCALBN):
5950     CASE_FLT_FN (BUILT_IN_SCALBLN):
5951       if (! flag_unsafe_math_optimizations)
5952         break;
5953
5954     CASE_FLT_FN (BUILT_IN_FMOD):
5955     CASE_FLT_FN (BUILT_IN_REMAINDER):
5956     CASE_FLT_FN (BUILT_IN_DREM):
5957     CASE_FLT_FN (BUILT_IN_POW):
5958       target = expand_builtin_mathfn_2 (exp, target, subtarget);
5959       if (target)
5960         return target;
5961       break;
5962
5963     CASE_FLT_FN (BUILT_IN_CEXPI):
5964       target = expand_builtin_cexpi (exp, target);
5965       gcc_assert (target);
5966       return target;
5967
5968     CASE_FLT_FN (BUILT_IN_SIN):
5969     CASE_FLT_FN (BUILT_IN_COS):
5970       if (! flag_unsafe_math_optimizations)
5971         break;
5972       target = expand_builtin_mathfn_3 (exp, target, subtarget);
5973       if (target)
5974         return target;
5975       break;
5976
5977     CASE_FLT_FN (BUILT_IN_SINCOS):
5978       if (! flag_unsafe_math_optimizations)
5979         break;
5980       target = expand_builtin_sincos (exp);
5981       if (target)
5982         return target;
5983       break;
5984
5985     case BUILT_IN_APPLY_ARGS:
5986       return expand_builtin_apply_args ();
5987
5988       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5989          FUNCTION with a copy of the parameters described by
5990          ARGUMENTS, and ARGSIZE.  It returns a block of memory
5991          allocated on the stack into which is stored all the registers
5992          that might possibly be used for returning the result of a
5993          function.  ARGUMENTS is the value returned by
5994          __builtin_apply_args.  ARGSIZE is the number of bytes of
5995          arguments that must be copied.  ??? How should this value be
5996          computed?  We'll also need a safe worst case value for varargs
5997          functions.  */
5998     case BUILT_IN_APPLY:
5999       if (!validate_arglist (exp, POINTER_TYPE,
6000                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
6001           && !validate_arglist (exp, REFERENCE_TYPE,
6002                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6003         return const0_rtx;
6004       else
6005         {
6006           rtx ops[3];
6007
6008           ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
6009           ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
6010           ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
6011
6012           return expand_builtin_apply (ops[0], ops[1], ops[2]);
6013         }
6014
6015       /* __builtin_return (RESULT) causes the function to return the
6016          value described by RESULT.  RESULT is address of the block of
6017          memory returned by __builtin_apply.  */
6018     case BUILT_IN_RETURN:
6019       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6020         expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
6021       return const0_rtx;
6022
6023     case BUILT_IN_SAVEREGS:
6024       return expand_builtin_saveregs ();
6025
6026     case BUILT_IN_VA_ARG_PACK:
6027       /* All valid uses of __builtin_va_arg_pack () are removed during
6028          inlining.  */
6029       error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
6030       return const0_rtx;
6031
6032     case BUILT_IN_VA_ARG_PACK_LEN:
6033       /* All valid uses of __builtin_va_arg_pack_len () are removed during
6034          inlining.  */
6035       error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
6036       return const0_rtx;
6037
6038       /* Return the address of the first anonymous stack arg.  */
6039     case BUILT_IN_NEXT_ARG:
6040       if (fold_builtin_next_arg (exp, false))
6041         return const0_rtx;
6042       return expand_builtin_next_arg ();
6043
6044     case BUILT_IN_CLEAR_CACHE:
6045       target = expand_builtin___clear_cache (exp);
6046       if (target)
6047         return target;
6048       break;
6049
6050     case BUILT_IN_CLASSIFY_TYPE:
6051       return expand_builtin_classify_type (exp);
6052
6053     case BUILT_IN_CONSTANT_P:
6054       return const0_rtx;
6055
6056     case BUILT_IN_FRAME_ADDRESS:
6057     case BUILT_IN_RETURN_ADDRESS:
6058       return expand_builtin_frame_address (fndecl, exp);
6059
6060     /* Returns the address of the area where the structure is returned.
6061        0 otherwise.  */
6062     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
6063       if (call_expr_nargs (exp) != 0
6064           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
6065           || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
6066         return const0_rtx;
6067       else
6068         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6069
6070     case BUILT_IN_ALLOCA:
6071     case BUILT_IN_ALLOCA_WITH_ALIGN:
6072       /* If the allocation stems from the declaration of a variable-sized
6073          object, it cannot accumulate.  */
6074       target = expand_builtin_alloca (exp, CALL_ALLOCA_FOR_VAR_P (exp));
6075       if (target)
6076         return target;
6077       break;
6078
6079     case BUILT_IN_STACK_SAVE:
6080       return expand_stack_save ();
6081
6082     case BUILT_IN_STACK_RESTORE:
6083       expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6084       return const0_rtx;
6085
6086     case BUILT_IN_BSWAP16:
6087     case BUILT_IN_BSWAP32:
6088     case BUILT_IN_BSWAP64:
6089       target = expand_builtin_bswap (target_mode, exp, target, subtarget);
6090       if (target)
6091         return target;
6092       break;
6093
6094     CASE_INT_FN (BUILT_IN_FFS):
6095     case BUILT_IN_FFSIMAX:
6096       target = expand_builtin_unop (target_mode, exp, target,
6097                                     subtarget, ffs_optab);
6098       if (target)
6099         return target;
6100       break;
6101
6102     CASE_INT_FN (BUILT_IN_CLZ):
6103     case BUILT_IN_CLZIMAX:
6104       target = expand_builtin_unop (target_mode, exp, target,
6105                                     subtarget, clz_optab);
6106       if (target)
6107         return target;
6108       break;
6109
6110     CASE_INT_FN (BUILT_IN_CTZ):
6111     case BUILT_IN_CTZIMAX:
6112       target = expand_builtin_unop (target_mode, exp, target,
6113                                     subtarget, ctz_optab);
6114       if (target)
6115         return target;
6116       break;
6117
6118     CASE_INT_FN (BUILT_IN_CLRSB):
6119     case BUILT_IN_CLRSBIMAX:
6120       target = expand_builtin_unop (target_mode, exp, target,
6121                                     subtarget, clrsb_optab);
6122       if (target)
6123         return target;
6124       break;
6125
6126     CASE_INT_FN (BUILT_IN_POPCOUNT):
6127     case BUILT_IN_POPCOUNTIMAX:
6128       target = expand_builtin_unop (target_mode, exp, target,
6129                                     subtarget, popcount_optab);
6130       if (target)
6131         return target;
6132       break;
6133
6134     CASE_INT_FN (BUILT_IN_PARITY):
6135     case BUILT_IN_PARITYIMAX:
6136       target = expand_builtin_unop (target_mode, exp, target,
6137                                     subtarget, parity_optab);
6138       if (target)
6139         return target;
6140       break;
6141
6142     case BUILT_IN_STRLEN:
6143       target = expand_builtin_strlen (exp, target, target_mode);
6144       if (target)
6145         return target;
6146       break;
6147
6148     case BUILT_IN_STRCPY:
6149       target = expand_builtin_strcpy (exp, target);
6150       if (target)
6151         return target;
6152       break;
6153
6154     case BUILT_IN_STRNCPY:
6155       target = expand_builtin_strncpy (exp, target);
6156       if (target)
6157         return target;
6158       break;
6159
6160     case BUILT_IN_STPCPY:
6161       target = expand_builtin_stpcpy (exp, target, mode);
6162       if (target)
6163         return target;
6164       break;
6165
6166     case BUILT_IN_MEMCPY:
6167       target = expand_builtin_memcpy (exp, target);
6168       if (target)
6169         return target;
6170       break;
6171
6172     case BUILT_IN_MEMPCPY:
6173       target = expand_builtin_mempcpy (exp, target, mode);
6174       if (target)
6175         return target;
6176       break;
6177
6178     case BUILT_IN_MEMSET:
6179       target = expand_builtin_memset (exp, target, mode);
6180       if (target)
6181         return target;
6182       break;
6183
6184     case BUILT_IN_BZERO:
6185       target = expand_builtin_bzero (exp);
6186       if (target)
6187         return target;
6188       break;
6189
6190     case BUILT_IN_STRCMP:
6191       target = expand_builtin_strcmp (exp, target);
6192       if (target)
6193         return target;
6194       break;
6195
6196     case BUILT_IN_STRNCMP:
6197       target = expand_builtin_strncmp (exp, target, mode);
6198       if (target)
6199         return target;
6200       break;
6201
6202     case BUILT_IN_BCMP:
6203     case BUILT_IN_MEMCMP:
6204       target = expand_builtin_memcmp (exp, target, mode);
6205       if (target)
6206         return target;
6207       break;
6208
6209     case BUILT_IN_SETJMP:
6210       /* This should have been lowered to the builtins below.  */
6211       gcc_unreachable ();
6212
6213     case BUILT_IN_SETJMP_SETUP:
6214       /* __builtin_setjmp_setup is passed a pointer to an array of five words
6215           and the receiver label.  */
6216       if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6217         {
6218           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6219                                       VOIDmode, EXPAND_NORMAL);
6220           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6221           rtx label_r = label_rtx (label);
6222
6223           /* This is copied from the handling of non-local gotos.  */
6224           expand_builtin_setjmp_setup (buf_addr, label_r);
6225           nonlocal_goto_handler_labels
6226             = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6227                                  nonlocal_goto_handler_labels);
6228           /* ??? Do not let expand_label treat us as such since we would
6229              not want to be both on the list of non-local labels and on
6230              the list of forced labels.  */
6231           FORCED_LABEL (label) = 0;
6232           return const0_rtx;
6233         }
6234       break;
6235
6236     case BUILT_IN_SETJMP_DISPATCHER:
6237        /* __builtin_setjmp_dispatcher is passed the dispatcher label.  */
6238       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6239         {
6240           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6241           rtx label_r = label_rtx (label);
6242
6243           /* Remove the dispatcher label from the list of non-local labels
6244              since the receiver labels have been added to it above.  */
6245           remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6246           return const0_rtx;
6247         }
6248       break;
6249
6250     case BUILT_IN_SETJMP_RECEIVER:
6251        /* __builtin_setjmp_receiver is passed the receiver label.  */
6252       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6253         {
6254           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6255           rtx label_r = label_rtx (label);
6256
6257           expand_builtin_setjmp_receiver (label_r);
6258           return const0_rtx;
6259         }
6260       break;
6261
6262       /* __builtin_longjmp is passed a pointer to an array of five words.
6263          It's similar to the C library longjmp function but works with
6264          __builtin_setjmp above.  */
6265     case BUILT_IN_LONGJMP:
6266       if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6267         {
6268           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6269                                       VOIDmode, EXPAND_NORMAL);
6270           rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6271
6272           if (value != const1_rtx)
6273             {
6274               error ("%<__builtin_longjmp%> second argument must be 1");
6275               return const0_rtx;
6276             }
6277
6278           expand_builtin_longjmp (buf_addr, value);
6279           return const0_rtx;
6280         }
6281       break;
6282
6283     case BUILT_IN_NONLOCAL_GOTO:
6284       target = expand_builtin_nonlocal_goto (exp);
6285       if (target)
6286         return target;
6287       break;
6288
6289       /* This updates the setjmp buffer that is its argument with the value
6290          of the current stack pointer.  */
6291     case BUILT_IN_UPDATE_SETJMP_BUF:
6292       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6293         {
6294           rtx buf_addr
6295             = expand_normal (CALL_EXPR_ARG (exp, 0));
6296
6297           expand_builtin_update_setjmp_buf (buf_addr);
6298           return const0_rtx;
6299         }
6300       break;
6301
6302     case BUILT_IN_TRAP:
6303       expand_builtin_trap ();
6304       return const0_rtx;
6305
6306     case BUILT_IN_UNREACHABLE:
6307       expand_builtin_unreachable ();
6308       return const0_rtx;
6309
6310     CASE_FLT_FN (BUILT_IN_SIGNBIT):
6311     case BUILT_IN_SIGNBITD32:
6312     case BUILT_IN_SIGNBITD64:
6313     case BUILT_IN_SIGNBITD128:
6314       target = expand_builtin_signbit (exp, target);
6315       if (target)
6316         return target;
6317       break;
6318
6319       /* Various hooks for the DWARF 2 __throw routine.  */
6320     case BUILT_IN_UNWIND_INIT:
6321       expand_builtin_unwind_init ();
6322       return const0_rtx;
6323     case BUILT_IN_DWARF_CFA:
6324       return virtual_cfa_rtx;
6325 #ifdef DWARF2_UNWIND_INFO
6326     case BUILT_IN_DWARF_SP_COLUMN:
6327       return expand_builtin_dwarf_sp_column ();
6328     case BUILT_IN_INIT_DWARF_REG_SIZES:
6329       expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6330       return const0_rtx;
6331 #endif
6332     case BUILT_IN_FROB_RETURN_ADDR:
6333       return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6334     case BUILT_IN_EXTRACT_RETURN_ADDR:
6335       return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6336     case BUILT_IN_EH_RETURN:
6337       expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6338                                 CALL_EXPR_ARG (exp, 1));
6339       return const0_rtx;
6340 #ifdef EH_RETURN_DATA_REGNO
6341     case BUILT_IN_EH_RETURN_DATA_REGNO:
6342       return expand_builtin_eh_return_data_regno (exp);
6343 #endif
6344     case BUILT_IN_EXTEND_POINTER:
6345       return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6346     case BUILT_IN_EH_POINTER:
6347       return expand_builtin_eh_pointer (exp);
6348     case BUILT_IN_EH_FILTER:
6349       return expand_builtin_eh_filter (exp);
6350     case BUILT_IN_EH_COPY_VALUES:
6351       return expand_builtin_eh_copy_values (exp);
6352
6353     case BUILT_IN_VA_START:
6354       return expand_builtin_va_start (exp);
6355     case BUILT_IN_VA_END:
6356       return expand_builtin_va_end (exp);
6357     case BUILT_IN_VA_COPY:
6358       return expand_builtin_va_copy (exp);
6359     case BUILT_IN_EXPECT:
6360       return expand_builtin_expect (exp, target);
6361     case BUILT_IN_ASSUME_ALIGNED:
6362       return expand_builtin_assume_aligned (exp, target);
6363     case BUILT_IN_PREFETCH:
6364       expand_builtin_prefetch (exp);
6365       return const0_rtx;
6366
6367     case BUILT_IN_INIT_TRAMPOLINE:
6368       return expand_builtin_init_trampoline (exp, true);
6369     case BUILT_IN_INIT_HEAP_TRAMPOLINE:
6370       return expand_builtin_init_trampoline (exp, false);
6371     case BUILT_IN_ADJUST_TRAMPOLINE:
6372       return expand_builtin_adjust_trampoline (exp);
6373
6374     case BUILT_IN_FORK:
6375     case BUILT_IN_EXECL:
6376     case BUILT_IN_EXECV:
6377     case BUILT_IN_EXECLP:
6378     case BUILT_IN_EXECLE:
6379     case BUILT_IN_EXECVP:
6380     case BUILT_IN_EXECVE:
6381       target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6382       if (target)
6383         return target;
6384       break;
6385
6386     case BUILT_IN_SYNC_FETCH_AND_ADD_1:
6387     case BUILT_IN_SYNC_FETCH_AND_ADD_2:
6388     case BUILT_IN_SYNC_FETCH_AND_ADD_4:
6389     case BUILT_IN_SYNC_FETCH_AND_ADD_8:
6390     case BUILT_IN_SYNC_FETCH_AND_ADD_16:
6391       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_ADD_1);
6392       target = expand_builtin_sync_operation (mode, exp, PLUS, false, target);
6393       if (target)
6394         return target;
6395       break;
6396
6397     case BUILT_IN_SYNC_FETCH_AND_SUB_1:
6398     case BUILT_IN_SYNC_FETCH_AND_SUB_2:
6399     case BUILT_IN_SYNC_FETCH_AND_SUB_4:
6400     case BUILT_IN_SYNC_FETCH_AND_SUB_8:
6401     case BUILT_IN_SYNC_FETCH_AND_SUB_16:
6402       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_SUB_1);
6403       target = expand_builtin_sync_operation (mode, exp, MINUS, false, target);
6404       if (target)
6405         return target;
6406       break;
6407
6408     case BUILT_IN_SYNC_FETCH_AND_OR_1:
6409     case BUILT_IN_SYNC_FETCH_AND_OR_2:
6410     case BUILT_IN_SYNC_FETCH_AND_OR_4:
6411     case BUILT_IN_SYNC_FETCH_AND_OR_8:
6412     case BUILT_IN_SYNC_FETCH_AND_OR_16:
6413       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_OR_1);
6414       target = expand_builtin_sync_operation (mode, exp, IOR, false, target);
6415       if (target)
6416         return target;
6417       break;
6418
6419     case BUILT_IN_SYNC_FETCH_AND_AND_1:
6420     case BUILT_IN_SYNC_FETCH_AND_AND_2:
6421     case BUILT_IN_SYNC_FETCH_AND_AND_4:
6422     case BUILT_IN_SYNC_FETCH_AND_AND_8:
6423     case BUILT_IN_SYNC_FETCH_AND_AND_16:
6424       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_AND_1);
6425       target = expand_builtin_sync_operation (mode, exp, AND, false, target);
6426       if (target)
6427         return target;
6428       break;
6429
6430     case BUILT_IN_SYNC_FETCH_AND_XOR_1:
6431     case BUILT_IN_SYNC_FETCH_AND_XOR_2:
6432     case BUILT_IN_SYNC_FETCH_AND_XOR_4:
6433     case BUILT_IN_SYNC_FETCH_AND_XOR_8:
6434     case BUILT_IN_SYNC_FETCH_AND_XOR_16:
6435       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_XOR_1);
6436       target = expand_builtin_sync_operation (mode, exp, XOR, false, target);
6437       if (target)
6438         return target;
6439       break;
6440
6441     case BUILT_IN_SYNC_FETCH_AND_NAND_1:
6442     case BUILT_IN_SYNC_FETCH_AND_NAND_2:
6443     case BUILT_IN_SYNC_FETCH_AND_NAND_4:
6444     case BUILT_IN_SYNC_FETCH_AND_NAND_8:
6445     case BUILT_IN_SYNC_FETCH_AND_NAND_16:
6446       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_NAND_1);
6447       target = expand_builtin_sync_operation (mode, exp, NOT, false, target);
6448       if (target)
6449         return target;
6450       break;
6451
6452     case BUILT_IN_SYNC_ADD_AND_FETCH_1:
6453     case BUILT_IN_SYNC_ADD_AND_FETCH_2:
6454     case BUILT_IN_SYNC_ADD_AND_FETCH_4:
6455     case BUILT_IN_SYNC_ADD_AND_FETCH_8:
6456     case BUILT_IN_SYNC_ADD_AND_FETCH_16:
6457       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_ADD_AND_FETCH_1);
6458       target = expand_builtin_sync_operation (mode, exp, PLUS, true, target);
6459       if (target)
6460         return target;
6461       break;
6462
6463     case BUILT_IN_SYNC_SUB_AND_FETCH_1:
6464     case BUILT_IN_SYNC_SUB_AND_FETCH_2:
6465     case BUILT_IN_SYNC_SUB_AND_FETCH_4:
6466     case BUILT_IN_SYNC_SUB_AND_FETCH_8:
6467     case BUILT_IN_SYNC_SUB_AND_FETCH_16:
6468       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_SUB_AND_FETCH_1);
6469       target = expand_builtin_sync_operation (mode, exp, MINUS, true, target);
6470       if (target)
6471         return target;
6472       break;
6473
6474     case BUILT_IN_SYNC_OR_AND_FETCH_1:
6475     case BUILT_IN_SYNC_OR_AND_FETCH_2:
6476     case BUILT_IN_SYNC_OR_AND_FETCH_4:
6477     case BUILT_IN_SYNC_OR_AND_FETCH_8:
6478     case BUILT_IN_SYNC_OR_AND_FETCH_16:
6479       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_OR_AND_FETCH_1);
6480       target = expand_builtin_sync_operation (mode, exp, IOR, true, target);
6481       if (target)
6482         return target;
6483       break;
6484
6485     case BUILT_IN_SYNC_AND_AND_FETCH_1:
6486     case BUILT_IN_SYNC_AND_AND_FETCH_2:
6487     case BUILT_IN_SYNC_AND_AND_FETCH_4:
6488     case BUILT_IN_SYNC_AND_AND_FETCH_8:
6489     case BUILT_IN_SYNC_AND_AND_FETCH_16:
6490       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_AND_AND_FETCH_1);
6491       target = expand_builtin_sync_operation (mode, exp, AND, true, target);
6492       if (target)
6493         return target;
6494       break;
6495
6496     case BUILT_IN_SYNC_XOR_AND_FETCH_1:
6497     case BUILT_IN_SYNC_XOR_AND_FETCH_2:
6498     case BUILT_IN_SYNC_XOR_AND_FETCH_4:
6499     case BUILT_IN_SYNC_XOR_AND_FETCH_8:
6500     case BUILT_IN_SYNC_XOR_AND_FETCH_16:
6501       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_XOR_AND_FETCH_1);
6502       target = expand_builtin_sync_operation (mode, exp, XOR, true, target);
6503       if (target)
6504         return target;
6505       break;
6506
6507     case BUILT_IN_SYNC_NAND_AND_FETCH_1:
6508     case BUILT_IN_SYNC_NAND_AND_FETCH_2:
6509     case BUILT_IN_SYNC_NAND_AND_FETCH_4:
6510     case BUILT_IN_SYNC_NAND_AND_FETCH_8:
6511     case BUILT_IN_SYNC_NAND_AND_FETCH_16:
6512       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_NAND_AND_FETCH_1);
6513       target = expand_builtin_sync_operation (mode, exp, NOT, true, target);
6514       if (target)
6515         return target;
6516       break;
6517
6518     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1:
6519     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2:
6520     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4:
6521     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8:
6522     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16:
6523       if (mode == VOIDmode)
6524         mode = TYPE_MODE (boolean_type_node);
6525       if (!target || !register_operand (target, mode))
6526         target = gen_reg_rtx (mode);
6527
6528       mode = get_builtin_sync_mode
6529                                 (fcode - BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1);
6530       target = expand_builtin_compare_and_swap (mode, exp, true, target);
6531       if (target)
6532         return target;
6533       break;
6534
6535     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1:
6536     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2:
6537     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4:
6538     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8:
6539     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16:
6540       mode = get_builtin_sync_mode
6541                                 (fcode - BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1);
6542       target = expand_builtin_compare_and_swap (mode, exp, false, target);
6543       if (target)
6544         return target;
6545       break;
6546
6547     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1:
6548     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2:
6549     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4:
6550     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8:
6551     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16:
6552       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_TEST_AND_SET_1);
6553       target = expand_builtin_sync_lock_test_and_set (mode, exp, target);
6554       if (target)
6555         return target;
6556       break;
6557
6558     case BUILT_IN_SYNC_LOCK_RELEASE_1:
6559     case BUILT_IN_SYNC_LOCK_RELEASE_2:
6560     case BUILT_IN_SYNC_LOCK_RELEASE_4:
6561     case BUILT_IN_SYNC_LOCK_RELEASE_8:
6562     case BUILT_IN_SYNC_LOCK_RELEASE_16:
6563       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_RELEASE_1);
6564       expand_builtin_sync_lock_release (mode, exp);
6565       return const0_rtx;
6566
6567     case BUILT_IN_SYNC_SYNCHRONIZE:
6568       expand_builtin_sync_synchronize ();
6569       return const0_rtx;
6570
6571     case BUILT_IN_ATOMIC_EXCHANGE_1:
6572     case BUILT_IN_ATOMIC_EXCHANGE_2:
6573     case BUILT_IN_ATOMIC_EXCHANGE_4:
6574     case BUILT_IN_ATOMIC_EXCHANGE_8:
6575     case BUILT_IN_ATOMIC_EXCHANGE_16:
6576       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_EXCHANGE_1);
6577       target = expand_builtin_atomic_exchange (mode, exp, target);
6578       if (target)
6579         return target;
6580       break;
6581
6582     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1:
6583     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2:
6584     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4:
6585     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8:
6586     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16:
6587       {
6588         unsigned int nargs, z;
6589         VEC(tree,gc) *vec;
6590
6591         mode =
6592             get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1);
6593         target = expand_builtin_atomic_compare_exchange (mode, exp, target);
6594         if (target)
6595           return target;
6596
6597         /* If this is turned into an external library call, the weak parameter
6598            must be dropped to match the expected parameter list.  */
6599         nargs = call_expr_nargs (exp);
6600         vec = VEC_alloc (tree, gc, nargs - 1);
6601         for (z = 0; z < 3; z++)
6602           VEC_quick_push (tree, vec, CALL_EXPR_ARG (exp, z));
6603         /* Skip the boolean weak parameter.  */
6604         for (z = 4; z < 6; z++)
6605           VEC_quick_push (tree, vec, CALL_EXPR_ARG (exp, z));
6606         exp = build_call_vec (TREE_TYPE (exp), CALL_EXPR_FN (exp), vec);
6607         break;
6608       }
6609
6610     case BUILT_IN_ATOMIC_LOAD_1:
6611     case BUILT_IN_ATOMIC_LOAD_2:
6612     case BUILT_IN_ATOMIC_LOAD_4:
6613     case BUILT_IN_ATOMIC_LOAD_8:
6614     case BUILT_IN_ATOMIC_LOAD_16:
6615       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_LOAD_1);
6616       target = expand_builtin_atomic_load (mode, exp, target);
6617       if (target)
6618         return target;
6619       break;
6620
6621     case BUILT_IN_ATOMIC_STORE_1:
6622     case BUILT_IN_ATOMIC_STORE_2:
6623     case BUILT_IN_ATOMIC_STORE_4:
6624     case BUILT_IN_ATOMIC_STORE_8:
6625     case BUILT_IN_ATOMIC_STORE_16:
6626       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_STORE_1);
6627       target = expand_builtin_atomic_store (mode, exp);
6628       if (target)
6629         return const0_rtx;
6630       break;
6631
6632     case BUILT_IN_ATOMIC_ADD_FETCH_1:
6633     case BUILT_IN_ATOMIC_ADD_FETCH_2:
6634     case BUILT_IN_ATOMIC_ADD_FETCH_4:
6635     case BUILT_IN_ATOMIC_ADD_FETCH_8:
6636     case BUILT_IN_ATOMIC_ADD_FETCH_16:
6637       {
6638         enum built_in_function lib;
6639         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1);
6640         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_ADD_1 +
6641                                        (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1));
6642         target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, true,
6643                                                  ignore, lib);
6644         if (target)
6645           return target;
6646         break;
6647       }
6648     case BUILT_IN_ATOMIC_SUB_FETCH_1:
6649     case BUILT_IN_ATOMIC_SUB_FETCH_2:
6650     case BUILT_IN_ATOMIC_SUB_FETCH_4:
6651     case BUILT_IN_ATOMIC_SUB_FETCH_8:
6652     case BUILT_IN_ATOMIC_SUB_FETCH_16:
6653       {
6654         enum built_in_function lib;
6655         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1);
6656         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_SUB_1 +
6657                                        (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1));
6658         target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, true,
6659                                                  ignore, lib);
6660         if (target)
6661           return target;
6662         break;
6663       }
6664     case BUILT_IN_ATOMIC_AND_FETCH_1:
6665     case BUILT_IN_ATOMIC_AND_FETCH_2:
6666     case BUILT_IN_ATOMIC_AND_FETCH_4:
6667     case BUILT_IN_ATOMIC_AND_FETCH_8:
6668     case BUILT_IN_ATOMIC_AND_FETCH_16:
6669       {
6670         enum built_in_function lib;
6671         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_AND_FETCH_1);
6672         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_AND_1 +
6673                                        (fcode - BUILT_IN_ATOMIC_AND_FETCH_1));
6674         target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, true,
6675                                                  ignore, lib);
6676         if (target)
6677           return target;
6678         break;
6679       }
6680     case BUILT_IN_ATOMIC_NAND_FETCH_1:
6681     case BUILT_IN_ATOMIC_NAND_FETCH_2:
6682     case BUILT_IN_ATOMIC_NAND_FETCH_4:
6683     case BUILT_IN_ATOMIC_NAND_FETCH_8:
6684     case BUILT_IN_ATOMIC_NAND_FETCH_16:
6685       {
6686         enum built_in_function lib;
6687         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1);
6688         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_NAND_1 +
6689                                        (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1));
6690         target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, true,
6691                                                  ignore, lib);
6692         if (target)
6693           return target;
6694         break;
6695       }
6696     case BUILT_IN_ATOMIC_XOR_FETCH_1:
6697     case BUILT_IN_ATOMIC_XOR_FETCH_2:
6698     case BUILT_IN_ATOMIC_XOR_FETCH_4:
6699     case BUILT_IN_ATOMIC_XOR_FETCH_8:
6700     case BUILT_IN_ATOMIC_XOR_FETCH_16:
6701       {
6702         enum built_in_function lib;
6703         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1);
6704         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_XOR_1 +
6705                                        (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1));
6706         target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, true,
6707                                                  ignore, lib);
6708         if (target)
6709           return target;
6710         break;
6711       }
6712     case BUILT_IN_ATOMIC_OR_FETCH_1:
6713     case BUILT_IN_ATOMIC_OR_FETCH_2:
6714     case BUILT_IN_ATOMIC_OR_FETCH_4:
6715     case BUILT_IN_ATOMIC_OR_FETCH_8:
6716     case BUILT_IN_ATOMIC_OR_FETCH_16:
6717       {
6718         enum built_in_function lib;
6719         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_OR_FETCH_1);
6720         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_OR_1 +
6721                                        (fcode - BUILT_IN_ATOMIC_OR_FETCH_1));
6722         target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, true,
6723                                                  ignore, lib);
6724         if (target)
6725           return target;
6726         break;
6727       }
6728     case BUILT_IN_ATOMIC_FETCH_ADD_1:
6729     case BUILT_IN_ATOMIC_FETCH_ADD_2:
6730     case BUILT_IN_ATOMIC_FETCH_ADD_4:
6731     case BUILT_IN_ATOMIC_FETCH_ADD_8:
6732     case BUILT_IN_ATOMIC_FETCH_ADD_16:
6733       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_ADD_1);
6734       target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, false,
6735                                                ignore, BUILT_IN_NONE);
6736       if (target)
6737         return target;
6738       break;
6739
6740     case BUILT_IN_ATOMIC_FETCH_SUB_1:
6741     case BUILT_IN_ATOMIC_FETCH_SUB_2:
6742     case BUILT_IN_ATOMIC_FETCH_SUB_4:
6743     case BUILT_IN_ATOMIC_FETCH_SUB_8:
6744     case BUILT_IN_ATOMIC_FETCH_SUB_16:
6745       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_SUB_1);
6746       target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, false,
6747                                                ignore, BUILT_IN_NONE);
6748       if (target)
6749         return target;
6750       break;
6751
6752     case BUILT_IN_ATOMIC_FETCH_AND_1:
6753     case BUILT_IN_ATOMIC_FETCH_AND_2:
6754     case BUILT_IN_ATOMIC_FETCH_AND_4:
6755     case BUILT_IN_ATOMIC_FETCH_AND_8:
6756     case BUILT_IN_ATOMIC_FETCH_AND_16:
6757       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_AND_1);
6758       target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, false,
6759                                                ignore, BUILT_IN_NONE);
6760       if (target)
6761         return target;
6762       break;
6763
6764     case BUILT_IN_ATOMIC_FETCH_NAND_1:
6765     case BUILT_IN_ATOMIC_FETCH_NAND_2:
6766     case BUILT_IN_ATOMIC_FETCH_NAND_4:
6767     case BUILT_IN_ATOMIC_FETCH_NAND_8:
6768     case BUILT_IN_ATOMIC_FETCH_NAND_16:
6769       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_NAND_1);
6770       target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, false,
6771                                                ignore, BUILT_IN_NONE);
6772       if (target)
6773         return target;
6774       break;
6775
6776     case BUILT_IN_ATOMIC_FETCH_XOR_1:
6777     case BUILT_IN_ATOMIC_FETCH_XOR_2:
6778     case BUILT_IN_ATOMIC_FETCH_XOR_4:
6779     case BUILT_IN_ATOMIC_FETCH_XOR_8:
6780     case BUILT_IN_ATOMIC_FETCH_XOR_16:
6781       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_XOR_1);
6782       target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, false,
6783                                                ignore, BUILT_IN_NONE);
6784       if (target)
6785         return target;
6786       break;
6787
6788     case BUILT_IN_ATOMIC_FETCH_OR_1:
6789     case BUILT_IN_ATOMIC_FETCH_OR_2:
6790     case BUILT_IN_ATOMIC_FETCH_OR_4:
6791     case BUILT_IN_ATOMIC_FETCH_OR_8:
6792     case BUILT_IN_ATOMIC_FETCH_OR_16:
6793       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_OR_1);
6794       target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, false,
6795                                                ignore, BUILT_IN_NONE);
6796       if (target)
6797         return target;
6798       break;
6799
6800     case BUILT_IN_ATOMIC_TEST_AND_SET:
6801       return expand_builtin_atomic_test_and_set (exp, target);
6802
6803     case BUILT_IN_ATOMIC_CLEAR:
6804       return expand_builtin_atomic_clear (exp);
6805
6806     case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
6807       return expand_builtin_atomic_always_lock_free (exp);
6808
6809     case BUILT_IN_ATOMIC_IS_LOCK_FREE:
6810       target = expand_builtin_atomic_is_lock_free (exp);
6811       if (target)
6812         return target;
6813       break;
6814
6815     case BUILT_IN_ATOMIC_THREAD_FENCE:
6816       expand_builtin_atomic_thread_fence (exp);
6817       return const0_rtx;
6818
6819     case BUILT_IN_ATOMIC_SIGNAL_FENCE:
6820       expand_builtin_atomic_signal_fence (exp);
6821       return const0_rtx;
6822
6823     case BUILT_IN_OBJECT_SIZE:
6824       return expand_builtin_object_size (exp);
6825
6826     case BUILT_IN_MEMCPY_CHK:
6827     case BUILT_IN_MEMPCPY_CHK:
6828     case BUILT_IN_MEMMOVE_CHK:
6829     case BUILT_IN_MEMSET_CHK:
6830       target = expand_builtin_memory_chk (exp, target, mode, fcode);
6831       if (target)
6832         return target;
6833       break;
6834
6835     case BUILT_IN_STRCPY_CHK:
6836     case BUILT_IN_STPCPY_CHK:
6837     case BUILT_IN_STRNCPY_CHK:
6838     case BUILT_IN_STPNCPY_CHK:
6839     case BUILT_IN_STRCAT_CHK:
6840     case BUILT_IN_STRNCAT_CHK:
6841     case BUILT_IN_SNPRINTF_CHK:
6842     case BUILT_IN_VSNPRINTF_CHK:
6843       maybe_emit_chk_warning (exp, fcode);
6844       break;
6845
6846     case BUILT_IN_SPRINTF_CHK:
6847     case BUILT_IN_VSPRINTF_CHK:
6848       maybe_emit_sprintf_chk_warning (exp, fcode);
6849       break;
6850
6851     case BUILT_IN_FREE:
6852       if (warn_free_nonheap_object)
6853         maybe_emit_free_warning (exp);
6854       break;
6855
6856     default:    /* just do library call, if unknown builtin */
6857       break;
6858     }
6859
6860   /* The switch statement above can drop through to cause the function
6861      to be called normally.  */
6862   return expand_call (exp, target, ignore);
6863 }
6864
6865 /* Determine whether a tree node represents a call to a built-in
6866    function.  If the tree T is a call to a built-in function with
6867    the right number of arguments of the appropriate types, return
6868    the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6869    Otherwise the return value is END_BUILTINS.  */
6870
6871 enum built_in_function
6872 builtin_mathfn_code (const_tree t)
6873 {
6874   const_tree fndecl, arg, parmlist;
6875   const_tree argtype, parmtype;
6876   const_call_expr_arg_iterator iter;
6877
6878   if (TREE_CODE (t) != CALL_EXPR
6879       || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6880     return END_BUILTINS;
6881
6882   fndecl = get_callee_fndecl (t);
6883   if (fndecl == NULL_TREE
6884       || TREE_CODE (fndecl) != FUNCTION_DECL
6885       || ! DECL_BUILT_IN (fndecl)
6886       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6887     return END_BUILTINS;
6888
6889   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6890   init_const_call_expr_arg_iterator (t, &iter);
6891   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6892     {
6893       /* If a function doesn't take a variable number of arguments,
6894          the last element in the list will have type `void'.  */
6895       parmtype = TREE_VALUE (parmlist);
6896       if (VOID_TYPE_P (parmtype))
6897         {
6898           if (more_const_call_expr_args_p (&iter))
6899             return END_BUILTINS;
6900           return DECL_FUNCTION_CODE (fndecl);
6901         }
6902
6903       if (! more_const_call_expr_args_p (&iter))
6904         return END_BUILTINS;
6905
6906       arg = next_const_call_expr_arg (&iter);
6907       argtype = TREE_TYPE (arg);
6908
6909       if (SCALAR_FLOAT_TYPE_P (parmtype))
6910         {
6911           if (! SCALAR_FLOAT_TYPE_P (argtype))
6912             return END_BUILTINS;
6913         }
6914       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6915         {
6916           if (! COMPLEX_FLOAT_TYPE_P (argtype))
6917             return END_BUILTINS;
6918         }
6919       else if (POINTER_TYPE_P (parmtype))
6920         {
6921           if (! POINTER_TYPE_P (argtype))
6922             return END_BUILTINS;
6923         }
6924       else if (INTEGRAL_TYPE_P (parmtype))
6925         {
6926           if (! INTEGRAL_TYPE_P (argtype))
6927             return END_BUILTINS;
6928         }
6929       else
6930         return END_BUILTINS;
6931     }
6932
6933   /* Variable-length argument list.  */
6934   return DECL_FUNCTION_CODE (fndecl);
6935 }
6936
6937 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6938    evaluate to a constant.  */
6939
6940 static tree
6941 fold_builtin_constant_p (tree arg)
6942 {
6943   /* We return 1 for a numeric type that's known to be a constant
6944      value at compile-time or for an aggregate type that's a
6945      literal constant.  */
6946   STRIP_NOPS (arg);
6947
6948   /* If we know this is a constant, emit the constant of one.  */
6949   if (CONSTANT_CLASS_P (arg)
6950       || (TREE_CODE (arg) == CONSTRUCTOR
6951           && TREE_CONSTANT (arg)))
6952     return integer_one_node;
6953   if (TREE_CODE (arg) == ADDR_EXPR)
6954     {
6955        tree op = TREE_OPERAND (arg, 0);
6956        if (TREE_CODE (op) == STRING_CST
6957            || (TREE_CODE (op) == ARRAY_REF
6958                && integer_zerop (TREE_OPERAND (op, 1))
6959                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6960          return integer_one_node;
6961     }
6962
6963   /* If this expression has side effects, show we don't know it to be a
6964      constant.  Likewise if it's a pointer or aggregate type since in
6965      those case we only want literals, since those are only optimized
6966      when generating RTL, not later.
6967      And finally, if we are compiling an initializer, not code, we
6968      need to return a definite result now; there's not going to be any
6969      more optimization done.  */
6970   if (TREE_SIDE_EFFECTS (arg)
6971       || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6972       || POINTER_TYPE_P (TREE_TYPE (arg))
6973       || cfun == 0
6974       || folding_initializer)
6975     return integer_zero_node;
6976
6977   return NULL_TREE;
6978 }
6979
6980 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6981    return it as a truthvalue.  */
6982
6983 static tree
6984 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6985 {
6986   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6987
6988   fn = builtin_decl_explicit (BUILT_IN_EXPECT);
6989   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6990   ret_type = TREE_TYPE (TREE_TYPE (fn));
6991   pred_type = TREE_VALUE (arg_types);
6992   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6993
6994   pred = fold_convert_loc (loc, pred_type, pred);
6995   expected = fold_convert_loc (loc, expected_type, expected);
6996   call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6997
6998   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6999                  build_int_cst (ret_type, 0));
7000 }
7001
7002 /* Fold a call to builtin_expect with arguments ARG0 and ARG1.  Return
7003    NULL_TREE if no simplification is possible.  */
7004
7005 static tree
7006 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
7007 {
7008   tree inner, fndecl, inner_arg0;
7009   enum tree_code code;
7010
7011   /* Distribute the expected value over short-circuiting operators.
7012      See through the cast from truthvalue_type_node to long.  */
7013   inner_arg0 = arg0;
7014   while (TREE_CODE (inner_arg0) == NOP_EXPR
7015          && INTEGRAL_TYPE_P (TREE_TYPE (inner_arg0))
7016          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner_arg0, 0))))
7017     inner_arg0 = TREE_OPERAND (inner_arg0, 0);
7018
7019   /* If this is a builtin_expect within a builtin_expect keep the
7020      inner one.  See through a comparison against a constant.  It
7021      might have been added to create a thruthvalue.  */
7022   inner = inner_arg0;
7023
7024   if (COMPARISON_CLASS_P (inner)
7025       && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
7026     inner = TREE_OPERAND (inner, 0);
7027
7028   if (TREE_CODE (inner) == CALL_EXPR
7029       && (fndecl = get_callee_fndecl (inner))
7030       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
7031       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
7032     return arg0;
7033
7034   inner = inner_arg0;
7035   code = TREE_CODE (inner);
7036   if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
7037     {
7038       tree op0 = TREE_OPERAND (inner, 0);
7039       tree op1 = TREE_OPERAND (inner, 1);
7040
7041       op0 = build_builtin_expect_predicate (loc, op0, arg1);
7042       op1 = build_builtin_expect_predicate (loc, op1, arg1);
7043       inner = build2 (code, TREE_TYPE (inner), op0, op1);
7044
7045       return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
7046     }
7047
7048   /* If the argument isn't invariant then there's nothing else we can do.  */
7049   if (!TREE_CONSTANT (inner_arg0))
7050     return NULL_TREE;
7051
7052   /* If we expect that a comparison against the argument will fold to
7053      a constant return the constant.  In practice, this means a true
7054      constant or the address of a non-weak symbol.  */
7055   inner = inner_arg0;
7056   STRIP_NOPS (inner);
7057   if (TREE_CODE (inner) == ADDR_EXPR)
7058     {
7059       do
7060         {
7061           inner = TREE_OPERAND (inner, 0);
7062         }
7063       while (TREE_CODE (inner) == COMPONENT_REF
7064              || TREE_CODE (inner) == ARRAY_REF);
7065       if ((TREE_CODE (inner) == VAR_DECL
7066            || TREE_CODE (inner) == FUNCTION_DECL)
7067           && DECL_WEAK (inner))
7068         return NULL_TREE;
7069     }
7070
7071   /* Otherwise, ARG0 already has the proper type for the return value.  */
7072   return arg0;
7073 }
7074
7075 /* Fold a call to __builtin_classify_type with argument ARG.  */
7076
7077 static tree
7078 fold_builtin_classify_type (tree arg)
7079 {
7080   if (arg == 0)
7081     return build_int_cst (integer_type_node, no_type_class);
7082
7083   return build_int_cst (integer_type_node, type_to_class (TREE_TYPE (arg)));
7084 }
7085
7086 /* Fold a call to __builtin_strlen with argument ARG.  */
7087
7088 static tree
7089 fold_builtin_strlen (location_t loc, tree type, tree arg)
7090 {
7091   if (!validate_arg (arg, POINTER_TYPE))
7092     return NULL_TREE;
7093   else
7094     {
7095       tree len = c_strlen (arg, 0);
7096
7097       if (len)
7098         return fold_convert_loc (loc, type, len);
7099
7100       return NULL_TREE;
7101     }
7102 }
7103
7104 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
7105
7106 static tree
7107 fold_builtin_inf (location_t loc, tree type, int warn)
7108 {
7109   REAL_VALUE_TYPE real;
7110
7111   /* __builtin_inff is intended to be usable to define INFINITY on all
7112      targets.  If an infinity is not available, INFINITY expands "to a
7113      positive constant of type float that overflows at translation
7114      time", footnote "In this case, using INFINITY will violate the
7115      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
7116      Thus we pedwarn to ensure this constraint violation is
7117      diagnosed.  */
7118   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
7119     pedwarn (loc, 0, "target format does not support infinity");
7120
7121   real_inf (&real);
7122   return build_real (type, real);
7123 }
7124
7125 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG.  */
7126
7127 static tree
7128 fold_builtin_nan (tree arg, tree type, int quiet)
7129 {
7130   REAL_VALUE_TYPE real;
7131   const char *str;
7132
7133   if (!validate_arg (arg, POINTER_TYPE))
7134     return NULL_TREE;
7135   str = c_getstr (arg);
7136   if (!str)
7137     return NULL_TREE;
7138
7139   if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
7140     return NULL_TREE;
7141
7142   return build_real (type, real);
7143 }
7144
7145 /* Return true if the floating point expression T has an integer value.
7146    We also allow +Inf, -Inf and NaN to be considered integer values.  */
7147
7148 static bool
7149 integer_valued_real_p (tree t)
7150 {
7151   switch (TREE_CODE (t))
7152     {
7153     case FLOAT_EXPR:
7154       return true;
7155
7156     case ABS_EXPR:
7157     case SAVE_EXPR:
7158       return integer_valued_real_p (TREE_OPERAND (t, 0));
7159
7160     case COMPOUND_EXPR:
7161     case MODIFY_EXPR:
7162     case BIND_EXPR:
7163       return integer_valued_real_p (TREE_OPERAND (t, 1));
7164
7165     case PLUS_EXPR:
7166     case MINUS_EXPR:
7167     case MULT_EXPR:
7168     case MIN_EXPR:
7169     case MAX_EXPR:
7170       return integer_valued_real_p (TREE_OPERAND (t, 0))
7171              && integer_valued_real_p (TREE_OPERAND (t, 1));
7172
7173     case COND_EXPR:
7174       return integer_valued_real_p (TREE_OPERAND (t, 1))
7175              && integer_valued_real_p (TREE_OPERAND (t, 2));
7176
7177     case REAL_CST:
7178       return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
7179
7180     case NOP_EXPR:
7181       {
7182         tree type = TREE_TYPE (TREE_OPERAND (t, 0));
7183         if (TREE_CODE (type) == INTEGER_TYPE)
7184           return true;
7185         if (TREE_CODE (type) == REAL_TYPE)
7186           return integer_valued_real_p (TREE_OPERAND (t, 0));
7187         break;
7188       }
7189
7190     case CALL_EXPR:
7191       switch (builtin_mathfn_code (t))
7192         {
7193         CASE_FLT_FN (BUILT_IN_CEIL):
7194         CASE_FLT_FN (BUILT_IN_FLOOR):
7195         CASE_FLT_FN (BUILT_IN_NEARBYINT):
7196         CASE_FLT_FN (BUILT_IN_RINT):
7197         CASE_FLT_FN (BUILT_IN_ROUND):
7198         CASE_FLT_FN (BUILT_IN_TRUNC):
7199           return true;
7200
7201         CASE_FLT_FN (BUILT_IN_FMIN):
7202         CASE_FLT_FN (BUILT_IN_FMAX):
7203           return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
7204             && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
7205
7206         default:
7207           break;
7208         }
7209       break;
7210
7211     default:
7212       break;
7213     }
7214   return false;
7215 }
7216
7217 /* FNDECL is assumed to be a builtin where truncation can be propagated
7218    across (for instance floor((double)f) == (double)floorf (f).
7219    Do the transformation for a call with argument ARG.  */
7220
7221 static tree
7222 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
7223 {
7224   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7225
7226   if (!validate_arg (arg, REAL_TYPE))
7227     return NULL_TREE;
7228
7229   /* Integer rounding functions are idempotent.  */
7230   if (fcode == builtin_mathfn_code (arg))
7231     return arg;
7232
7233   /* If argument is already integer valued, and we don't need to worry
7234      about setting errno, there's no need to perform rounding.  */
7235   if (! flag_errno_math && integer_valued_real_p (arg))
7236     return arg;
7237
7238   if (optimize)
7239     {
7240       tree arg0 = strip_float_extensions (arg);
7241       tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
7242       tree newtype = TREE_TYPE (arg0);
7243       tree decl;
7244
7245       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7246           && (decl = mathfn_built_in (newtype, fcode)))
7247         return fold_convert_loc (loc, ftype,
7248                                  build_call_expr_loc (loc, decl, 1,
7249                                                   fold_convert_loc (loc,
7250                                                                     newtype,
7251                                                                     arg0)));
7252     }
7253   return NULL_TREE;
7254 }
7255
7256 /* FNDECL is assumed to be builtin which can narrow the FP type of
7257    the argument, for instance lround((double)f) -> lroundf (f).
7258    Do the transformation for a call with argument ARG.  */
7259
7260 static tree
7261 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
7262 {
7263   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7264
7265   if (!validate_arg (arg, REAL_TYPE))
7266     return NULL_TREE;
7267
7268   /* If argument is already integer valued, and we don't need to worry
7269      about setting errno, there's no need to perform rounding.  */
7270   if (! flag_errno_math && integer_valued_real_p (arg))
7271     return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7272                         TREE_TYPE (TREE_TYPE (fndecl)), arg);
7273
7274   if (optimize)
7275     {
7276       tree ftype = TREE_TYPE (arg);
7277       tree arg0 = strip_float_extensions (arg);
7278       tree newtype = TREE_TYPE (arg0);
7279       tree decl;
7280
7281       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7282           && (decl = mathfn_built_in (newtype, fcode)))
7283         return build_call_expr_loc (loc, decl, 1,
7284                                 fold_convert_loc (loc, newtype, arg0));
7285     }
7286
7287   /* Canonicalize iround (x) to lround (x) on ILP32 targets where
7288      sizeof (int) == sizeof (long).  */
7289   if (TYPE_PRECISION (integer_type_node)
7290       == TYPE_PRECISION (long_integer_type_node))
7291     {
7292       tree newfn = NULL_TREE;
7293       switch (fcode)
7294         {
7295         CASE_FLT_FN (BUILT_IN_ICEIL):
7296           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
7297           break;
7298
7299         CASE_FLT_FN (BUILT_IN_IFLOOR):
7300           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
7301           break;
7302
7303         CASE_FLT_FN (BUILT_IN_IROUND):
7304           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
7305           break;
7306
7307         CASE_FLT_FN (BUILT_IN_IRINT):
7308           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7309           break;
7310
7311         default:
7312           break;
7313         }
7314
7315       if (newfn)
7316         {
7317           tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7318           return fold_convert_loc (loc,
7319                                    TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7320         }
7321     }
7322
7323   /* Canonicalize llround (x) to lround (x) on LP64 targets where
7324      sizeof (long long) == sizeof (long).  */
7325   if (TYPE_PRECISION (long_long_integer_type_node)
7326       == TYPE_PRECISION (long_integer_type_node))
7327     {
7328       tree newfn = NULL_TREE;
7329       switch (fcode)
7330         {
7331         CASE_FLT_FN (BUILT_IN_LLCEIL):
7332           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
7333           break;
7334
7335         CASE_FLT_FN (BUILT_IN_LLFLOOR):
7336           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
7337           break;
7338
7339         CASE_FLT_FN (BUILT_IN_LLROUND):
7340           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
7341           break;
7342
7343         CASE_FLT_FN (BUILT_IN_LLRINT):
7344           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7345           break;
7346
7347         default:
7348           break;
7349         }
7350
7351       if (newfn)
7352         {
7353           tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7354           return fold_convert_loc (loc,
7355                                    TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7356         }
7357     }
7358
7359   return NULL_TREE;
7360 }
7361
7362 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG.  TYPE is the
7363    return type.  Return NULL_TREE if no simplification can be made.  */
7364
7365 static tree
7366 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7367 {
7368   tree res;
7369
7370   if (!validate_arg (arg, COMPLEX_TYPE)
7371       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7372     return NULL_TREE;
7373
7374   /* Calculate the result when the argument is a constant.  */
7375   if (TREE_CODE (arg) == COMPLEX_CST
7376       && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7377                               type, mpfr_hypot)))
7378     return res;
7379
7380   if (TREE_CODE (arg) == COMPLEX_EXPR)
7381     {
7382       tree real = TREE_OPERAND (arg, 0);
7383       tree imag = TREE_OPERAND (arg, 1);
7384
7385       /* If either part is zero, cabs is fabs of the other.  */
7386       if (real_zerop (real))
7387         return fold_build1_loc (loc, ABS_EXPR, type, imag);
7388       if (real_zerop (imag))
7389         return fold_build1_loc (loc, ABS_EXPR, type, real);
7390
7391       /* cabs(x+xi) -> fabs(x)*sqrt(2).  */
7392       if (flag_unsafe_math_optimizations
7393           && operand_equal_p (real, imag, OEP_PURE_SAME))
7394         {
7395           const REAL_VALUE_TYPE sqrt2_trunc
7396             = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7397           STRIP_NOPS (real);
7398           return fold_build2_loc (loc, MULT_EXPR, type,
7399                               fold_build1_loc (loc, ABS_EXPR, type, real),
7400                               build_real (type, sqrt2_trunc));
7401         }
7402     }
7403
7404   /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z).  */
7405   if (TREE_CODE (arg) == NEGATE_EXPR
7406       || TREE_CODE (arg) == CONJ_EXPR)
7407     return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7408
7409   /* Don't do this when optimizing for size.  */
7410   if (flag_unsafe_math_optimizations
7411       && optimize && optimize_function_for_speed_p (cfun))
7412     {
7413       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7414
7415       if (sqrtfn != NULL_TREE)
7416         {
7417           tree rpart, ipart, result;
7418
7419           arg = builtin_save_expr (arg);
7420
7421           rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7422           ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7423
7424           rpart = builtin_save_expr (rpart);
7425           ipart = builtin_save_expr (ipart);
7426
7427           result = fold_build2_loc (loc, PLUS_EXPR, type,
7428                                 fold_build2_loc (loc, MULT_EXPR, type,
7429                                              rpart, rpart),
7430                                 fold_build2_loc (loc, MULT_EXPR, type,
7431                                              ipart, ipart));
7432
7433           return build_call_expr_loc (loc, sqrtfn, 1, result);
7434         }
7435     }
7436
7437   return NULL_TREE;
7438 }
7439
7440 /* Build a complex (inf +- 0i) for the result of cproj.  TYPE is the
7441    complex tree type of the result.  If NEG is true, the imaginary
7442    zero is negative.  */
7443
7444 static tree
7445 build_complex_cproj (tree type, bool neg)
7446 {
7447   REAL_VALUE_TYPE rinf, rzero = dconst0;
7448
7449   real_inf (&rinf);
7450   rzero.sign = neg;
7451   return build_complex (type, build_real (TREE_TYPE (type), rinf),
7452                         build_real (TREE_TYPE (type), rzero));
7453 }
7454
7455 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG.  TYPE is the
7456    return type.  Return NULL_TREE if no simplification can be made.  */
7457
7458 static tree
7459 fold_builtin_cproj (location_t loc, tree arg, tree type)
7460 {
7461   if (!validate_arg (arg, COMPLEX_TYPE)
7462       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7463     return NULL_TREE;
7464
7465   /* If there are no infinities, return arg.  */
7466   if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type))))
7467     return non_lvalue_loc (loc, arg);
7468
7469   /* Calculate the result when the argument is a constant.  */
7470   if (TREE_CODE (arg) == COMPLEX_CST)
7471     {
7472       const REAL_VALUE_TYPE *real = TREE_REAL_CST_PTR (TREE_REALPART (arg));
7473       const REAL_VALUE_TYPE *imag = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
7474
7475       if (real_isinf (real) || real_isinf (imag))
7476         return build_complex_cproj (type, imag->sign);
7477       else
7478         return arg;
7479     }
7480   else if (TREE_CODE (arg) == COMPLEX_EXPR)
7481     {
7482       tree real = TREE_OPERAND (arg, 0);
7483       tree imag = TREE_OPERAND (arg, 1);
7484
7485       STRIP_NOPS (real);
7486       STRIP_NOPS (imag);
7487
7488       /* If the real part is inf and the imag part is known to be
7489          nonnegative, return (inf + 0i).  Remember side-effects are
7490          possible in the imag part.  */
7491       if (TREE_CODE (real) == REAL_CST
7492           && real_isinf (TREE_REAL_CST_PTR (real))
7493           && tree_expr_nonnegative_p (imag))
7494         return omit_one_operand_loc (loc, type,
7495                                      build_complex_cproj (type, false),
7496                                      arg);
7497
7498       /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7499          Remember side-effects are possible in the real part.  */
7500       if (TREE_CODE (imag) == REAL_CST
7501           && real_isinf (TREE_REAL_CST_PTR (imag)))
7502         return
7503           omit_one_operand_loc (loc, type,
7504                                 build_complex_cproj (type, TREE_REAL_CST_PTR
7505                                                      (imag)->sign), arg);
7506     }
7507
7508   return NULL_TREE;
7509 }
7510
7511 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7512    Return NULL_TREE if no simplification can be made.  */
7513
7514 static tree
7515 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7516 {
7517
7518   enum built_in_function fcode;
7519   tree res;
7520
7521   if (!validate_arg (arg, REAL_TYPE))
7522     return NULL_TREE;
7523
7524   /* Calculate the result when the argument is a constant.  */
7525   if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7526     return res;
7527
7528   /* Optimize sqrt(expN(x)) = expN(x*0.5).  */
7529   fcode = builtin_mathfn_code (arg);
7530   if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7531     {
7532       tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7533       arg = fold_build2_loc (loc, MULT_EXPR, type,
7534                          CALL_EXPR_ARG (arg, 0),
7535                          build_real (type, dconsthalf));
7536       return build_call_expr_loc (loc, expfn, 1, arg);
7537     }
7538
7539   /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)).  */
7540   if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7541     {
7542       tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7543
7544       if (powfn)
7545         {
7546           tree arg0 = CALL_EXPR_ARG (arg, 0);
7547           tree tree_root;
7548           /* The inner root was either sqrt or cbrt.  */
7549           /* This was a conditional expression but it triggered a bug
7550              in Sun C 5.5.  */
7551           REAL_VALUE_TYPE dconstroot;
7552           if (BUILTIN_SQRT_P (fcode))
7553             dconstroot = dconsthalf;
7554           else
7555             dconstroot = dconst_third ();
7556
7557           /* Adjust for the outer root.  */
7558           SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7559           dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7560           tree_root = build_real (type, dconstroot);
7561           return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7562         }
7563     }
7564
7565   /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5).  */
7566   if (flag_unsafe_math_optimizations
7567       && (fcode == BUILT_IN_POW
7568           || fcode == BUILT_IN_POWF
7569           || fcode == BUILT_IN_POWL))
7570     {
7571       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7572       tree arg0 = CALL_EXPR_ARG (arg, 0);
7573       tree arg1 = CALL_EXPR_ARG (arg, 1);
7574       tree narg1;
7575       if (!tree_expr_nonnegative_p (arg0))
7576         arg0 = build1 (ABS_EXPR, type, arg0);
7577       narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7578                            build_real (type, dconsthalf));
7579       return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7580     }
7581
7582   return NULL_TREE;
7583 }
7584
7585 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7586    Return NULL_TREE if no simplification can be made.  */
7587
7588 static tree
7589 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7590 {
7591   const enum built_in_function fcode = builtin_mathfn_code (arg);
7592   tree res;
7593
7594   if (!validate_arg (arg, REAL_TYPE))
7595     return NULL_TREE;
7596
7597   /* Calculate the result when the argument is a constant.  */
7598   if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7599     return res;
7600
7601   if (flag_unsafe_math_optimizations)
7602     {
7603       /* Optimize cbrt(expN(x)) -> expN(x/3).  */
7604       if (BUILTIN_EXPONENT_P (fcode))
7605         {
7606           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7607           const REAL_VALUE_TYPE third_trunc =
7608             real_value_truncate (TYPE_MODE (type), dconst_third ());
7609           arg = fold_build2_loc (loc, MULT_EXPR, type,
7610                              CALL_EXPR_ARG (arg, 0),
7611                              build_real (type, third_trunc));
7612           return build_call_expr_loc (loc, expfn, 1, arg);
7613         }
7614
7615       /* Optimize cbrt(sqrt(x)) -> pow(x,1/6).  */
7616       if (BUILTIN_SQRT_P (fcode))
7617         {
7618           tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7619
7620           if (powfn)
7621             {
7622               tree arg0 = CALL_EXPR_ARG (arg, 0);
7623               tree tree_root;
7624               REAL_VALUE_TYPE dconstroot = dconst_third ();
7625
7626               SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7627               dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7628               tree_root = build_real (type, dconstroot);
7629               return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7630             }
7631         }
7632
7633       /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative.  */
7634       if (BUILTIN_CBRT_P (fcode))
7635         {
7636           tree arg0 = CALL_EXPR_ARG (arg, 0);
7637           if (tree_expr_nonnegative_p (arg0))
7638             {
7639               tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7640
7641               if (powfn)
7642                 {
7643                   tree tree_root;
7644                   REAL_VALUE_TYPE dconstroot;
7645
7646                   real_arithmetic (&dconstroot, MULT_EXPR,
7647                                    dconst_third_ptr (), dconst_third_ptr ());
7648                   dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7649                   tree_root = build_real (type, dconstroot);
7650                   return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7651                 }
7652             }
7653         }
7654
7655       /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative.  */
7656       if (fcode == BUILT_IN_POW
7657           || fcode == BUILT_IN_POWF
7658           || fcode == BUILT_IN_POWL)
7659         {
7660           tree arg00 = CALL_EXPR_ARG (arg, 0);
7661           tree arg01 = CALL_EXPR_ARG (arg, 1);
7662           if (tree_expr_nonnegative_p (arg00))
7663             {
7664               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7665               const REAL_VALUE_TYPE dconstroot
7666                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7667               tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7668                                          build_real (type, dconstroot));
7669               return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7670             }
7671         }
7672     }
7673   return NULL_TREE;
7674 }
7675
7676 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7677    TYPE is the type of the return value.  Return NULL_TREE if no
7678    simplification can be made.  */
7679
7680 static tree
7681 fold_builtin_cos (location_t loc,
7682                   tree arg, tree type, tree fndecl)
7683 {
7684   tree res, narg;
7685
7686   if (!validate_arg (arg, REAL_TYPE))
7687     return NULL_TREE;
7688
7689   /* Calculate the result when the argument is a constant.  */
7690   if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7691     return res;
7692
7693   /* Optimize cos(-x) into cos (x).  */
7694   if ((narg = fold_strip_sign_ops (arg)))
7695     return build_call_expr_loc (loc, fndecl, 1, narg);
7696
7697   return NULL_TREE;
7698 }
7699
7700 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7701    Return NULL_TREE if no simplification can be made.  */
7702
7703 static tree
7704 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7705 {
7706   if (validate_arg (arg, REAL_TYPE))
7707     {
7708       tree res, narg;
7709
7710       /* Calculate the result when the argument is a constant.  */
7711       if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7712         return res;
7713
7714       /* Optimize cosh(-x) into cosh (x).  */
7715       if ((narg = fold_strip_sign_ops (arg)))
7716         return build_call_expr_loc (loc, fndecl, 1, narg);
7717     }
7718
7719   return NULL_TREE;
7720 }
7721
7722 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7723    argument ARG.  TYPE is the type of the return value.  Return
7724    NULL_TREE if no simplification can be made.  */
7725
7726 static tree
7727 fold_builtin_ccos (location_t loc, tree arg, tree type, tree fndecl,
7728                    bool hyper)
7729 {
7730   if (validate_arg (arg, COMPLEX_TYPE)
7731       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7732     {
7733       tree tmp;
7734
7735       /* Calculate the result when the argument is a constant.  */
7736       if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7737         return tmp;
7738
7739       /* Optimize fn(-x) into fn(x).  */
7740       if ((tmp = fold_strip_sign_ops (arg)))
7741         return build_call_expr_loc (loc, fndecl, 1, tmp);
7742     }
7743
7744   return NULL_TREE;
7745 }
7746
7747 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7748    Return NULL_TREE if no simplification can be made.  */
7749
7750 static tree
7751 fold_builtin_tan (tree arg, tree type)
7752 {
7753   enum built_in_function fcode;
7754   tree res;
7755
7756   if (!validate_arg (arg, REAL_TYPE))
7757     return NULL_TREE;
7758
7759   /* Calculate the result when the argument is a constant.  */
7760   if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7761     return res;
7762
7763   /* Optimize tan(atan(x)) = x.  */
7764   fcode = builtin_mathfn_code (arg);
7765   if (flag_unsafe_math_optimizations
7766       && (fcode == BUILT_IN_ATAN
7767           || fcode == BUILT_IN_ATANF
7768           || fcode == BUILT_IN_ATANL))
7769     return CALL_EXPR_ARG (arg, 0);
7770
7771   return NULL_TREE;
7772 }
7773
7774 /* Fold function call to builtin sincos, sincosf, or sincosl.  Return
7775    NULL_TREE if no simplification can be made.  */
7776
7777 static tree
7778 fold_builtin_sincos (location_t loc,
7779                      tree arg0, tree arg1, tree arg2)
7780 {
7781   tree type;
7782   tree res, fn, call;
7783
7784   if (!validate_arg (arg0, REAL_TYPE)
7785       || !validate_arg (arg1, POINTER_TYPE)
7786       || !validate_arg (arg2, POINTER_TYPE))
7787     return NULL_TREE;
7788
7789   type = TREE_TYPE (arg0);
7790
7791   /* Calculate the result when the argument is a constant.  */
7792   if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7793     return res;
7794
7795   /* Canonicalize sincos to cexpi.  */
7796   if (!TARGET_C99_FUNCTIONS)
7797     return NULL_TREE;
7798   fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7799   if (!fn)
7800     return NULL_TREE;
7801
7802   call = build_call_expr_loc (loc, fn, 1, arg0);
7803   call = builtin_save_expr (call);
7804
7805   return build2 (COMPOUND_EXPR, void_type_node,
7806                  build2 (MODIFY_EXPR, void_type_node,
7807                          build_fold_indirect_ref_loc (loc, arg1),
7808                          build1 (IMAGPART_EXPR, type, call)),
7809                  build2 (MODIFY_EXPR, void_type_node,
7810                          build_fold_indirect_ref_loc (loc, arg2),
7811                          build1 (REALPART_EXPR, type, call)));
7812 }
7813
7814 /* Fold function call to builtin cexp, cexpf, or cexpl.  Return
7815    NULL_TREE if no simplification can be made.  */
7816
7817 static tree
7818 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7819 {
7820   tree rtype;
7821   tree realp, imagp, ifn;
7822   tree res;
7823
7824   if (!validate_arg (arg0, COMPLEX_TYPE)
7825       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7826     return NULL_TREE;
7827
7828   /* Calculate the result when the argument is a constant.  */
7829   if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7830     return res;
7831
7832   rtype = TREE_TYPE (TREE_TYPE (arg0));
7833
7834   /* In case we can figure out the real part of arg0 and it is constant zero
7835      fold to cexpi.  */
7836   if (!TARGET_C99_FUNCTIONS)
7837     return NULL_TREE;
7838   ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7839   if (!ifn)
7840     return NULL_TREE;
7841
7842   if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7843       && real_zerop (realp))
7844     {
7845       tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7846       return build_call_expr_loc (loc, ifn, 1, narg);
7847     }
7848
7849   /* In case we can easily decompose real and imaginary parts split cexp
7850      to exp (r) * cexpi (i).  */
7851   if (flag_unsafe_math_optimizations
7852       && realp)
7853     {
7854       tree rfn, rcall, icall;
7855
7856       rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7857       if (!rfn)
7858         return NULL_TREE;
7859
7860       imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7861       if (!imagp)
7862         return NULL_TREE;
7863
7864       icall = build_call_expr_loc (loc, ifn, 1, imagp);
7865       icall = builtin_save_expr (icall);
7866       rcall = build_call_expr_loc (loc, rfn, 1, realp);
7867       rcall = builtin_save_expr (rcall);
7868       return fold_build2_loc (loc, COMPLEX_EXPR, type,
7869                           fold_build2_loc (loc, MULT_EXPR, rtype,
7870                                        rcall,
7871                                        fold_build1_loc (loc, REALPART_EXPR,
7872                                                     rtype, icall)),
7873                           fold_build2_loc (loc, MULT_EXPR, rtype,
7874                                        rcall,
7875                                        fold_build1_loc (loc, IMAGPART_EXPR,
7876                                                     rtype, icall)));
7877     }
7878
7879   return NULL_TREE;
7880 }
7881
7882 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7883    Return NULL_TREE if no simplification can be made.  */
7884
7885 static tree
7886 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7887 {
7888   if (!validate_arg (arg, REAL_TYPE))
7889     return NULL_TREE;
7890
7891   /* Optimize trunc of constant value.  */
7892   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7893     {
7894       REAL_VALUE_TYPE r, x;
7895       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7896
7897       x = TREE_REAL_CST (arg);
7898       real_trunc (&r, TYPE_MODE (type), &x);
7899       return build_real (type, r);
7900     }
7901
7902   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7903 }
7904
7905 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7906    Return NULL_TREE if no simplification can be made.  */
7907
7908 static tree
7909 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7910 {
7911   if (!validate_arg (arg, REAL_TYPE))
7912     return NULL_TREE;
7913
7914   /* Optimize floor of constant value.  */
7915   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7916     {
7917       REAL_VALUE_TYPE x;
7918
7919       x = TREE_REAL_CST (arg);
7920       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7921         {
7922           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7923           REAL_VALUE_TYPE r;
7924
7925           real_floor (&r, TYPE_MODE (type), &x);
7926           return build_real (type, r);
7927         }
7928     }
7929
7930   /* Fold floor (x) where x is nonnegative to trunc (x).  */
7931   if (tree_expr_nonnegative_p (arg))
7932     {
7933       tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7934       if (truncfn)
7935         return build_call_expr_loc (loc, truncfn, 1, arg);
7936     }
7937
7938   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7939 }
7940
7941 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7942    Return NULL_TREE if no simplification can be made.  */
7943
7944 static tree
7945 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7946 {
7947   if (!validate_arg (arg, REAL_TYPE))
7948     return NULL_TREE;
7949
7950   /* Optimize ceil of constant value.  */
7951   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7952     {
7953       REAL_VALUE_TYPE x;
7954
7955       x = TREE_REAL_CST (arg);
7956       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7957         {
7958           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7959           REAL_VALUE_TYPE r;
7960
7961           real_ceil (&r, TYPE_MODE (type), &x);
7962           return build_real (type, r);
7963         }
7964     }
7965
7966   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7967 }
7968
7969 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7970    Return NULL_TREE if no simplification can be made.  */
7971
7972 static tree
7973 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7974 {
7975   if (!validate_arg (arg, REAL_TYPE))
7976     return NULL_TREE;
7977
7978   /* Optimize round of constant value.  */
7979   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7980     {
7981       REAL_VALUE_TYPE x;
7982
7983       x = TREE_REAL_CST (arg);
7984       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7985         {
7986           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7987           REAL_VALUE_TYPE r;
7988
7989           real_round (&r, TYPE_MODE (type), &x);
7990           return build_real (type, r);
7991         }
7992     }
7993
7994   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7995 }
7996
7997 /* Fold function call to builtin lround, lroundf or lroundl (or the
7998    corresponding long long versions) and other rounding functions.  ARG
7999    is the argument to the call.  Return NULL_TREE if no simplification
8000    can be made.  */
8001
8002 static tree
8003 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
8004 {
8005   if (!validate_arg (arg, REAL_TYPE))
8006     return NULL_TREE;
8007
8008   /* Optimize lround of constant value.  */
8009   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
8010     {
8011       const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
8012
8013       if (real_isfinite (&x))
8014         {
8015           tree itype = TREE_TYPE (TREE_TYPE (fndecl));
8016           tree ftype = TREE_TYPE (arg);
8017           double_int val;
8018           REAL_VALUE_TYPE r;
8019
8020           switch (DECL_FUNCTION_CODE (fndecl))
8021             {
8022             CASE_FLT_FN (BUILT_IN_IFLOOR):
8023             CASE_FLT_FN (BUILT_IN_LFLOOR):
8024             CASE_FLT_FN (BUILT_IN_LLFLOOR):
8025               real_floor (&r, TYPE_MODE (ftype), &x);
8026               break;
8027
8028             CASE_FLT_FN (BUILT_IN_ICEIL):
8029             CASE_FLT_FN (BUILT_IN_LCEIL):
8030             CASE_FLT_FN (BUILT_IN_LLCEIL):
8031               real_ceil (&r, TYPE_MODE (ftype), &x);
8032               break;
8033
8034             CASE_FLT_FN (BUILT_IN_IROUND):
8035             CASE_FLT_FN (BUILT_IN_LROUND):
8036             CASE_FLT_FN (BUILT_IN_LLROUND):
8037               real_round (&r, TYPE_MODE (ftype), &x);
8038               break;
8039
8040             default:
8041               gcc_unreachable ();
8042             }
8043
8044           real_to_integer2 ((HOST_WIDE_INT *)&val.low, &val.high, &r);
8045           if (double_int_fits_to_tree_p (itype, val))
8046             return double_int_to_tree (itype, val);
8047         }
8048     }
8049
8050   switch (DECL_FUNCTION_CODE (fndecl))
8051     {
8052     CASE_FLT_FN (BUILT_IN_LFLOOR):
8053     CASE_FLT_FN (BUILT_IN_LLFLOOR):
8054       /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x).  */
8055       if (tree_expr_nonnegative_p (arg))
8056         return fold_build1_loc (loc, FIX_TRUNC_EXPR,
8057                             TREE_TYPE (TREE_TYPE (fndecl)), arg);
8058       break;
8059     default:;
8060     }
8061
8062   return fold_fixed_mathfn (loc, fndecl, arg);
8063 }
8064
8065 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
8066    and their long and long long variants (i.e. ffsl and ffsll).  ARG is
8067    the argument to the call.  Return NULL_TREE if no simplification can
8068    be made.  */
8069
8070 static tree
8071 fold_builtin_bitop (tree fndecl, tree arg)
8072 {
8073   if (!validate_arg (arg, INTEGER_TYPE))
8074     return NULL_TREE;
8075
8076   /* Optimize for constant argument.  */
8077   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
8078     {
8079       HOST_WIDE_INT hi, width, result;
8080       unsigned HOST_WIDE_INT lo;
8081       tree type;
8082
8083       type = TREE_TYPE (arg);
8084       width = TYPE_PRECISION (type);
8085       lo = TREE_INT_CST_LOW (arg);
8086
8087       /* Clear all the bits that are beyond the type's precision.  */
8088       if (width > HOST_BITS_PER_WIDE_INT)
8089         {
8090           hi = TREE_INT_CST_HIGH (arg);
8091           if (width < 2 * HOST_BITS_PER_WIDE_INT)
8092             hi &= ~((unsigned HOST_WIDE_INT) (-1)
8093                     << (width - HOST_BITS_PER_WIDE_INT));
8094         }
8095       else
8096         {
8097           hi = 0;
8098           if (width < HOST_BITS_PER_WIDE_INT)
8099             lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
8100         }
8101
8102       switch (DECL_FUNCTION_CODE (fndecl))
8103         {
8104         CASE_INT_FN (BUILT_IN_FFS):
8105           if (lo != 0)
8106             result = ffs_hwi (lo);
8107           else if (hi != 0)
8108             result = HOST_BITS_PER_WIDE_INT + ffs_hwi (hi);
8109           else
8110             result = 0;
8111           break;
8112
8113         CASE_INT_FN (BUILT_IN_CLZ):
8114           if (hi != 0)
8115             result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
8116           else if (lo != 0)
8117             result = width - floor_log2 (lo) - 1;
8118           else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
8119             result = width;
8120           break;
8121
8122         CASE_INT_FN (BUILT_IN_CTZ):
8123           if (lo != 0)
8124             result = ctz_hwi (lo);
8125           else if (hi != 0)
8126             result = HOST_BITS_PER_WIDE_INT + ctz_hwi (hi);
8127           else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
8128             result = width;
8129           break;
8130
8131         CASE_INT_FN (BUILT_IN_CLRSB):
8132           if (width > HOST_BITS_PER_WIDE_INT
8133               && (hi & ((unsigned HOST_WIDE_INT) 1
8134                         << (width - HOST_BITS_PER_WIDE_INT - 1))) != 0)
8135             {
8136               hi = ~hi & ~((unsigned HOST_WIDE_INT) (-1)
8137                            << (width - HOST_BITS_PER_WIDE_INT - 1));
8138               lo = ~lo;
8139             }
8140           else if (width <= HOST_BITS_PER_WIDE_INT
8141                    && (lo & ((unsigned HOST_WIDE_INT) 1 << (width - 1))) != 0)
8142             lo = ~lo & ~((unsigned HOST_WIDE_INT) (-1) << (width - 1));
8143           if (hi != 0)
8144             result = width - floor_log2 (hi) - 2 - HOST_BITS_PER_WIDE_INT;
8145           else if (lo != 0)
8146             result = width - floor_log2 (lo) - 2;
8147           else
8148             result = width - 1;
8149           break;
8150
8151         CASE_INT_FN (BUILT_IN_POPCOUNT):
8152           result = 0;
8153           while (lo)
8154             result++, lo &= lo - 1;
8155           while (hi)
8156             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
8157           break;
8158
8159         CASE_INT_FN (BUILT_IN_PARITY):
8160           result = 0;
8161           while (lo)
8162             result++, lo &= lo - 1;
8163           while (hi)
8164             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
8165           result &= 1;
8166           break;
8167
8168         default:
8169           gcc_unreachable ();
8170         }
8171
8172       return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
8173     }
8174
8175   return NULL_TREE;
8176 }
8177
8178 /* Fold function call to builtin_bswap and the short, long and long long
8179    variants.  Return NULL_TREE if no simplification can be made.  */
8180 static tree
8181 fold_builtin_bswap (tree fndecl, tree arg)
8182 {
8183   if (! validate_arg (arg, INTEGER_TYPE))
8184     return NULL_TREE;
8185
8186   /* Optimize constant value.  */
8187   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
8188     {
8189       HOST_WIDE_INT hi, width, r_hi = 0;
8190       unsigned HOST_WIDE_INT lo, r_lo = 0;
8191       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8192
8193       width = TYPE_PRECISION (type);
8194       lo = TREE_INT_CST_LOW (arg);
8195       hi = TREE_INT_CST_HIGH (arg);
8196
8197       switch (DECL_FUNCTION_CODE (fndecl))
8198         {
8199           case BUILT_IN_BSWAP16:
8200           case BUILT_IN_BSWAP32:
8201           case BUILT_IN_BSWAP64:
8202             {
8203               int s;
8204
8205               for (s = 0; s < width; s += 8)
8206                 {
8207                   int d = width - s - 8;
8208                   unsigned HOST_WIDE_INT byte;
8209
8210                   if (s < HOST_BITS_PER_WIDE_INT)
8211                     byte = (lo >> s) & 0xff;
8212                   else
8213                     byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
8214
8215                   if (d < HOST_BITS_PER_WIDE_INT)
8216                     r_lo |= byte << d;
8217                   else
8218                     r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
8219                 }
8220             }
8221
8222             break;
8223
8224         default:
8225           gcc_unreachable ();
8226         }
8227
8228       if (width < HOST_BITS_PER_WIDE_INT)
8229         return build_int_cst (type, r_lo);
8230       else
8231         return build_int_cst_wide (type, r_lo, r_hi);
8232     }
8233
8234   return NULL_TREE;
8235 }
8236
8237 /* A subroutine of fold_builtin to fold the various logarithmic
8238    functions.  Return NULL_TREE if no simplification can me made.
8239    FUNC is the corresponding MPFR logarithm function.  */
8240
8241 static tree
8242 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
8243                         int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8244 {
8245   if (validate_arg (arg, REAL_TYPE))
8246     {
8247       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8248       tree res;
8249       const enum built_in_function fcode = builtin_mathfn_code (arg);
8250
8251       /* Calculate the result when the argument is a constant.  */
8252       if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
8253         return res;
8254
8255       /* Special case, optimize logN(expN(x)) = x.  */
8256       if (flag_unsafe_math_optimizations
8257           && ((func == mpfr_log
8258                && (fcode == BUILT_IN_EXP
8259                    || fcode == BUILT_IN_EXPF
8260                    || fcode == BUILT_IN_EXPL))
8261               || (func == mpfr_log2
8262                   && (fcode == BUILT_IN_EXP2
8263                       || fcode == BUILT_IN_EXP2F
8264                       || fcode == BUILT_IN_EXP2L))
8265               || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
8266         return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8267
8268       /* Optimize logN(func()) for various exponential functions.  We
8269          want to determine the value "x" and the power "exponent" in
8270          order to transform logN(x**exponent) into exponent*logN(x).  */
8271       if (flag_unsafe_math_optimizations)
8272         {
8273           tree exponent = 0, x = 0;
8274
8275           switch (fcode)
8276           {
8277           CASE_FLT_FN (BUILT_IN_EXP):
8278             /* Prepare to do logN(exp(exponent) -> exponent*logN(e).  */
8279             x = build_real (type, real_value_truncate (TYPE_MODE (type),
8280                                                        dconst_e ()));
8281             exponent = CALL_EXPR_ARG (arg, 0);
8282             break;
8283           CASE_FLT_FN (BUILT_IN_EXP2):
8284             /* Prepare to do logN(exp2(exponent) -> exponent*logN(2).  */
8285             x = build_real (type, dconst2);
8286             exponent = CALL_EXPR_ARG (arg, 0);
8287             break;
8288           CASE_FLT_FN (BUILT_IN_EXP10):
8289           CASE_FLT_FN (BUILT_IN_POW10):
8290             /* Prepare to do logN(exp10(exponent) -> exponent*logN(10).  */
8291             {
8292               REAL_VALUE_TYPE dconst10;
8293               real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
8294               x = build_real (type, dconst10);
8295             }
8296             exponent = CALL_EXPR_ARG (arg, 0);
8297             break;
8298           CASE_FLT_FN (BUILT_IN_SQRT):
8299             /* Prepare to do logN(sqrt(x) -> 0.5*logN(x).  */
8300             x = CALL_EXPR_ARG (arg, 0);
8301             exponent = build_real (type, dconsthalf);
8302             break;
8303           CASE_FLT_FN (BUILT_IN_CBRT):
8304             /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x).  */
8305             x = CALL_EXPR_ARG (arg, 0);
8306             exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
8307                                                               dconst_third ()));
8308             break;
8309           CASE_FLT_FN (BUILT_IN_POW):
8310             /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x).  */
8311             x = CALL_EXPR_ARG (arg, 0);
8312             exponent = CALL_EXPR_ARG (arg, 1);
8313             break;
8314           default:
8315             break;
8316           }
8317
8318           /* Now perform the optimization.  */
8319           if (x && exponent)
8320             {
8321               tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
8322               return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
8323             }
8324         }
8325     }
8326
8327   return NULL_TREE;
8328 }
8329
8330 /* Fold a builtin function call to hypot, hypotf, or hypotl.  Return
8331    NULL_TREE if no simplification can be made.  */
8332
8333 static tree
8334 fold_builtin_hypot (location_t loc, tree fndecl,
8335                     tree arg0, tree arg1, tree type)
8336 {
8337   tree res, narg0, narg1;
8338
8339   if (!validate_arg (arg0, REAL_TYPE)
8340       || !validate_arg (arg1, REAL_TYPE))
8341     return NULL_TREE;
8342
8343   /* Calculate the result when the argument is a constant.  */
8344   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
8345     return res;
8346
8347   /* If either argument to hypot has a negate or abs, strip that off.
8348      E.g. hypot(-x,fabs(y)) -> hypot(x,y).  */
8349   narg0 = fold_strip_sign_ops (arg0);
8350   narg1 = fold_strip_sign_ops (arg1);
8351   if (narg0 || narg1)
8352     {
8353       return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
8354                               narg1 ? narg1 : arg1);
8355     }
8356
8357   /* If either argument is zero, hypot is fabs of the other.  */
8358   if (real_zerop (arg0))
8359     return fold_build1_loc (loc, ABS_EXPR, type, arg1);
8360   else if (real_zerop (arg1))
8361     return fold_build1_loc (loc, ABS_EXPR, type, arg0);
8362
8363   /* hypot(x,x) -> fabs(x)*sqrt(2).  */
8364   if (flag_unsafe_math_optimizations
8365       && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
8366     {
8367       const REAL_VALUE_TYPE sqrt2_trunc
8368         = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
8369       return fold_build2_loc (loc, MULT_EXPR, type,
8370                           fold_build1_loc (loc, ABS_EXPR, type, arg0),
8371                           build_real (type, sqrt2_trunc));
8372     }
8373
8374   return NULL_TREE;
8375 }
8376
8377
8378 /* Fold a builtin function call to pow, powf, or powl.  Return
8379    NULL_TREE if no simplification can be made.  */
8380 static tree
8381 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
8382 {
8383   tree res;
8384
8385   if (!validate_arg (arg0, REAL_TYPE)
8386        || !validate_arg (arg1, REAL_TYPE))
8387     return NULL_TREE;
8388
8389   /* Calculate the result when the argument is a constant.  */
8390   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8391     return res;
8392
8393   /* Optimize pow(1.0,y) = 1.0.  */
8394   if (real_onep (arg0))
8395     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8396
8397   if (TREE_CODE (arg1) == REAL_CST
8398       && !TREE_OVERFLOW (arg1))
8399     {
8400       REAL_VALUE_TYPE cint;
8401       REAL_VALUE_TYPE c;
8402       HOST_WIDE_INT n;
8403
8404       c = TREE_REAL_CST (arg1);
8405
8406       /* Optimize pow(x,0.0) = 1.0.  */
8407       if (REAL_VALUES_EQUAL (c, dconst0))
8408         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8409                                  arg0);
8410
8411       /* Optimize pow(x,1.0) = x.  */
8412       if (REAL_VALUES_EQUAL (c, dconst1))
8413         return arg0;
8414
8415       /* Optimize pow(x,-1.0) = 1.0/x.  */
8416       if (REAL_VALUES_EQUAL (c, dconstm1))
8417         return fold_build2_loc (loc, RDIV_EXPR, type,
8418                             build_real (type, dconst1), arg0);
8419
8420       /* Optimize pow(x,0.5) = sqrt(x).  */
8421       if (flag_unsafe_math_optimizations
8422           && REAL_VALUES_EQUAL (c, dconsthalf))
8423         {
8424           tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8425
8426           if (sqrtfn != NULL_TREE)
8427             return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8428         }
8429
8430       /* Optimize pow(x,1.0/3.0) = cbrt(x).  */
8431       if (flag_unsafe_math_optimizations)
8432         {
8433           const REAL_VALUE_TYPE dconstroot
8434             = real_value_truncate (TYPE_MODE (type), dconst_third ());
8435
8436           if (REAL_VALUES_EQUAL (c, dconstroot))
8437             {
8438               tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8439               if (cbrtfn != NULL_TREE)
8440                 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8441             }
8442         }
8443
8444       /* Check for an integer exponent.  */
8445       n = real_to_integer (&c);
8446       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8447       if (real_identical (&c, &cint))
8448         {
8449           /* Attempt to evaluate pow at compile-time, unless this should
8450              raise an exception.  */
8451           if (TREE_CODE (arg0) == REAL_CST
8452               && !TREE_OVERFLOW (arg0)
8453               && (n > 0
8454                   || (!flag_trapping_math && !flag_errno_math)
8455                   || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8456             {
8457               REAL_VALUE_TYPE x;
8458               bool inexact;
8459
8460               x = TREE_REAL_CST (arg0);
8461               inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8462               if (flag_unsafe_math_optimizations || !inexact)
8463                 return build_real (type, x);
8464             }
8465
8466           /* Strip sign ops from even integer powers.  */
8467           if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8468             {
8469               tree narg0 = fold_strip_sign_ops (arg0);
8470               if (narg0)
8471                 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8472             }
8473         }
8474     }
8475
8476   if (flag_unsafe_math_optimizations)
8477     {
8478       const enum built_in_function fcode = builtin_mathfn_code (arg0);
8479
8480       /* Optimize pow(expN(x),y) = expN(x*y).  */
8481       if (BUILTIN_EXPONENT_P (fcode))
8482         {
8483           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8484           tree arg = CALL_EXPR_ARG (arg0, 0);
8485           arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8486           return build_call_expr_loc (loc, expfn, 1, arg);
8487         }
8488
8489       /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
8490       if (BUILTIN_SQRT_P (fcode))
8491         {
8492           tree narg0 = CALL_EXPR_ARG (arg0, 0);
8493           tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8494                                     build_real (type, dconsthalf));
8495           return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8496         }
8497
8498       /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative.  */
8499       if (BUILTIN_CBRT_P (fcode))
8500         {
8501           tree arg = CALL_EXPR_ARG (arg0, 0);
8502           if (tree_expr_nonnegative_p (arg))
8503             {
8504               const REAL_VALUE_TYPE dconstroot
8505                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8506               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8507                                         build_real (type, dconstroot));
8508               return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8509             }
8510         }
8511
8512       /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative.  */
8513       if (fcode == BUILT_IN_POW
8514           || fcode == BUILT_IN_POWF
8515           || fcode == BUILT_IN_POWL)
8516         {
8517           tree arg00 = CALL_EXPR_ARG (arg0, 0);
8518           if (tree_expr_nonnegative_p (arg00))
8519             {
8520               tree arg01 = CALL_EXPR_ARG (arg0, 1);
8521               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8522               return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8523             }
8524         }
8525     }
8526
8527   return NULL_TREE;
8528 }
8529
8530 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8531    Return NULL_TREE if no simplification can be made.  */
8532 static tree
8533 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8534                    tree arg0, tree arg1, tree type)
8535 {
8536   if (!validate_arg (arg0, REAL_TYPE)
8537       || !validate_arg (arg1, INTEGER_TYPE))
8538     return NULL_TREE;
8539
8540   /* Optimize pow(1.0,y) = 1.0.  */
8541   if (real_onep (arg0))
8542     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8543
8544   if (host_integerp (arg1, 0))
8545     {
8546       HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8547
8548       /* Evaluate powi at compile-time.  */
8549       if (TREE_CODE (arg0) == REAL_CST
8550           && !TREE_OVERFLOW (arg0))
8551         {
8552           REAL_VALUE_TYPE x;
8553           x = TREE_REAL_CST (arg0);
8554           real_powi (&x, TYPE_MODE (type), &x, c);
8555           return build_real (type, x);
8556         }
8557
8558       /* Optimize pow(x,0) = 1.0.  */
8559       if (c == 0)
8560         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8561                                  arg0);
8562
8563       /* Optimize pow(x,1) = x.  */
8564       if (c == 1)
8565         return arg0;
8566
8567       /* Optimize pow(x,-1) = 1.0/x.  */
8568       if (c == -1)
8569         return fold_build2_loc (loc, RDIV_EXPR, type,
8570                            build_real (type, dconst1), arg0);
8571     }
8572
8573   return NULL_TREE;
8574 }
8575
8576 /* A subroutine of fold_builtin to fold the various exponent
8577    functions.  Return NULL_TREE if no simplification can be made.
8578    FUNC is the corresponding MPFR exponent function.  */
8579
8580 static tree
8581 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8582                        int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8583 {
8584   if (validate_arg (arg, REAL_TYPE))
8585     {
8586       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8587       tree res;
8588
8589       /* Calculate the result when the argument is a constant.  */
8590       if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8591         return res;
8592
8593       /* Optimize expN(logN(x)) = x.  */
8594       if (flag_unsafe_math_optimizations)
8595         {
8596           const enum built_in_function fcode = builtin_mathfn_code (arg);
8597
8598           if ((func == mpfr_exp
8599                && (fcode == BUILT_IN_LOG
8600                    || fcode == BUILT_IN_LOGF
8601                    || fcode == BUILT_IN_LOGL))
8602               || (func == mpfr_exp2
8603                   && (fcode == BUILT_IN_LOG2
8604                       || fcode == BUILT_IN_LOG2F
8605                       || fcode == BUILT_IN_LOG2L))
8606               || (func == mpfr_exp10
8607                   && (fcode == BUILT_IN_LOG10
8608                       || fcode == BUILT_IN_LOG10F
8609                       || fcode == BUILT_IN_LOG10L)))
8610             return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8611         }
8612     }
8613
8614   return NULL_TREE;
8615 }
8616
8617 /* Return true if VAR is a VAR_DECL or a component thereof.  */
8618
8619 static bool
8620 var_decl_component_p (tree var)
8621 {
8622   tree inner = var;
8623   while (handled_component_p (inner))
8624     inner = TREE_OPERAND (inner, 0);
8625   return SSA_VAR_P (inner);
8626 }
8627
8628 /* Fold function call to builtin memset.  Return
8629    NULL_TREE if no simplification can be made.  */
8630
8631 static tree
8632 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8633                      tree type, bool ignore)
8634 {
8635   tree var, ret, etype;
8636   unsigned HOST_WIDE_INT length, cval;
8637
8638   if (! validate_arg (dest, POINTER_TYPE)
8639       || ! validate_arg (c, INTEGER_TYPE)
8640       || ! validate_arg (len, INTEGER_TYPE))
8641     return NULL_TREE;
8642
8643   if (! host_integerp (len, 1))
8644     return NULL_TREE;
8645
8646   /* If the LEN parameter is zero, return DEST.  */
8647   if (integer_zerop (len))
8648     return omit_one_operand_loc (loc, type, dest, c);
8649
8650   if (TREE_CODE (c) != INTEGER_CST || TREE_SIDE_EFFECTS (dest))
8651     return NULL_TREE;
8652
8653   var = dest;
8654   STRIP_NOPS (var);
8655   if (TREE_CODE (var) != ADDR_EXPR)
8656     return NULL_TREE;
8657
8658   var = TREE_OPERAND (var, 0);
8659   if (TREE_THIS_VOLATILE (var))
8660     return NULL_TREE;
8661
8662   etype = TREE_TYPE (var);
8663   if (TREE_CODE (etype) == ARRAY_TYPE)
8664     etype = TREE_TYPE (etype);
8665
8666   if (!INTEGRAL_TYPE_P (etype)
8667       && !POINTER_TYPE_P (etype))
8668     return NULL_TREE;
8669
8670   if (! var_decl_component_p (var))
8671     return NULL_TREE;
8672
8673   length = tree_low_cst (len, 1);
8674   if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8675       || get_pointer_alignment (dest) / BITS_PER_UNIT < length)
8676     return NULL_TREE;
8677
8678   if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8679     return NULL_TREE;
8680
8681   if (integer_zerop (c))
8682     cval = 0;
8683   else
8684     {
8685       if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8686         return NULL_TREE;
8687
8688       cval = TREE_INT_CST_LOW (c);
8689       cval &= 0xff;
8690       cval |= cval << 8;
8691       cval |= cval << 16;
8692       cval |= (cval << 31) << 1;
8693     }
8694
8695   ret = build_int_cst_type (etype, cval);
8696   var = build_fold_indirect_ref_loc (loc,
8697                                  fold_convert_loc (loc,
8698                                                    build_pointer_type (etype),
8699                                                    dest));
8700   ret = build2 (MODIFY_EXPR, etype, var, ret);
8701   if (ignore)
8702     return ret;
8703
8704   return omit_one_operand_loc (loc, type, dest, ret);
8705 }
8706
8707 /* Fold function call to builtin memset.  Return
8708    NULL_TREE if no simplification can be made.  */
8709
8710 static tree
8711 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8712 {
8713   if (! validate_arg (dest, POINTER_TYPE)
8714       || ! validate_arg (size, INTEGER_TYPE))
8715     return NULL_TREE;
8716
8717   if (!ignore)
8718     return NULL_TREE;
8719
8720   /* New argument list transforming bzero(ptr x, int y) to
8721      memset(ptr x, int 0, size_t y).   This is done this way
8722      so that if it isn't expanded inline, we fallback to
8723      calling bzero instead of memset.  */
8724
8725   return fold_builtin_memset (loc, dest, integer_zero_node,
8726                               fold_convert_loc (loc, size_type_node, size),
8727                               void_type_node, ignore);
8728 }
8729
8730 /* Fold function call to builtin mem{{,p}cpy,move}.  Return
8731    NULL_TREE if no simplification can be made.
8732    If ENDP is 0, return DEST (like memcpy).
8733    If ENDP is 1, return DEST+LEN (like mempcpy).
8734    If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8735    If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8736    (memmove).   */
8737
8738 static tree
8739 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8740                         tree len, tree type, bool ignore, int endp)
8741 {
8742   tree destvar, srcvar, expr;
8743
8744   if (! validate_arg (dest, POINTER_TYPE)
8745       || ! validate_arg (src, POINTER_TYPE)
8746       || ! validate_arg (len, INTEGER_TYPE))
8747     return NULL_TREE;
8748
8749   /* If the LEN parameter is zero, return DEST.  */
8750   if (integer_zerop (len))
8751     return omit_one_operand_loc (loc, type, dest, src);
8752
8753   /* If SRC and DEST are the same (and not volatile), return
8754      DEST{,+LEN,+LEN-1}.  */
8755   if (operand_equal_p (src, dest, 0))
8756     expr = len;
8757   else
8758     {
8759       tree srctype, desttype;
8760       unsigned int src_align, dest_align;
8761       tree off0;
8762
8763       if (endp == 3)
8764         {
8765           src_align = get_pointer_alignment (src);
8766           dest_align = get_pointer_alignment (dest);
8767
8768           /* Both DEST and SRC must be pointer types.
8769              ??? This is what old code did.  Is the testing for pointer types
8770              really mandatory?
8771
8772              If either SRC is readonly or length is 1, we can use memcpy.  */
8773           if (!dest_align || !src_align)
8774             return NULL_TREE;
8775           if (readonly_data_expr (src)
8776               || (host_integerp (len, 1)
8777                   && (MIN (src_align, dest_align) / BITS_PER_UNIT
8778                       >= (unsigned HOST_WIDE_INT) tree_low_cst (len, 1))))
8779             {
8780               tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
8781               if (!fn)
8782                 return NULL_TREE;
8783               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8784             }
8785
8786           /* If *src and *dest can't overlap, optimize into memcpy as well.  */
8787           if (TREE_CODE (src) == ADDR_EXPR
8788               && TREE_CODE (dest) == ADDR_EXPR)
8789             {
8790               tree src_base, dest_base, fn;
8791               HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8792               HOST_WIDE_INT size = -1;
8793               HOST_WIDE_INT maxsize = -1;
8794
8795               srcvar = TREE_OPERAND (src, 0);
8796               src_base = get_ref_base_and_extent (srcvar, &src_offset,
8797                                                   &size, &maxsize);
8798               destvar = TREE_OPERAND (dest, 0);
8799               dest_base = get_ref_base_and_extent (destvar, &dest_offset,
8800                                                    &size, &maxsize);
8801               if (host_integerp (len, 1))
8802                 maxsize = tree_low_cst (len, 1);
8803               else
8804                 maxsize = -1;
8805               src_offset /= BITS_PER_UNIT;
8806               dest_offset /= BITS_PER_UNIT;
8807               if (SSA_VAR_P (src_base)
8808                   && SSA_VAR_P (dest_base))
8809                 {
8810                   if (operand_equal_p (src_base, dest_base, 0)
8811                       && ranges_overlap_p (src_offset, maxsize,
8812                                            dest_offset, maxsize))
8813                     return NULL_TREE;
8814                 }
8815               else if (TREE_CODE (src_base) == MEM_REF
8816                        && TREE_CODE (dest_base) == MEM_REF)
8817                 {
8818                   double_int off;
8819                   if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8820                                          TREE_OPERAND (dest_base, 0), 0))
8821                     return NULL_TREE;
8822                   off = double_int_add (mem_ref_offset (src_base),
8823                                         shwi_to_double_int (src_offset));
8824                   if (!double_int_fits_in_shwi_p (off))
8825                     return NULL_TREE;
8826                   src_offset = off.low;
8827                   off = double_int_add (mem_ref_offset (dest_base),
8828                                         shwi_to_double_int (dest_offset));
8829                   if (!double_int_fits_in_shwi_p (off))
8830                     return NULL_TREE;
8831                   dest_offset = off.low;
8832                   if (ranges_overlap_p (src_offset, maxsize,
8833                                         dest_offset, maxsize))
8834                     return NULL_TREE;
8835                 }
8836               else
8837                 return NULL_TREE;
8838
8839               fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
8840               if (!fn)
8841                 return NULL_TREE;
8842               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8843             }
8844
8845           /* If the destination and source do not alias optimize into
8846              memcpy as well.  */
8847           if ((is_gimple_min_invariant (dest)
8848                || TREE_CODE (dest) == SSA_NAME)
8849               && (is_gimple_min_invariant (src)
8850                   || TREE_CODE (src) == SSA_NAME))
8851             {
8852               ao_ref destr, srcr;
8853               ao_ref_init_from_ptr_and_size (&destr, dest, len);
8854               ao_ref_init_from_ptr_and_size (&srcr, src, len);
8855               if (!refs_may_alias_p_1 (&destr, &srcr, false))
8856                 {
8857                   tree fn;
8858                   fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
8859                   if (!fn)
8860                     return NULL_TREE;
8861                   return build_call_expr_loc (loc, fn, 3, dest, src, len);
8862                 }
8863             }
8864
8865           return NULL_TREE;
8866         }
8867
8868       if (!host_integerp (len, 0))
8869         return NULL_TREE;
8870       /* FIXME:
8871          This logic lose for arguments like (type *)malloc (sizeof (type)),
8872          since we strip the casts of up to VOID return value from malloc.
8873          Perhaps we ought to inherit type from non-VOID argument here?  */
8874       STRIP_NOPS (src);
8875       STRIP_NOPS (dest);
8876       if (!POINTER_TYPE_P (TREE_TYPE (src))
8877           || !POINTER_TYPE_P (TREE_TYPE (dest)))
8878         return NULL_TREE;
8879       /* As we fold (void *)(p + CST) to (void *)p + CST undo this here.  */
8880       if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8881         {
8882           tree tem = TREE_OPERAND (src, 0);
8883           STRIP_NOPS (tem);
8884           if (tem != TREE_OPERAND (src, 0))
8885             src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8886         }
8887       if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8888         {
8889           tree tem = TREE_OPERAND (dest, 0);
8890           STRIP_NOPS (tem);
8891           if (tem != TREE_OPERAND (dest, 0))
8892             dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8893         }
8894       srctype = TREE_TYPE (TREE_TYPE (src));
8895       if (TREE_CODE (srctype) == ARRAY_TYPE
8896           && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8897         {
8898           srctype = TREE_TYPE (srctype);
8899           STRIP_NOPS (src);
8900           src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8901         }
8902       desttype = TREE_TYPE (TREE_TYPE (dest));
8903       if (TREE_CODE (desttype) == ARRAY_TYPE
8904           && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8905         {
8906           desttype = TREE_TYPE (desttype);
8907           STRIP_NOPS (dest);
8908           dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8909         }
8910       if (TREE_ADDRESSABLE (srctype)
8911           || TREE_ADDRESSABLE (desttype))
8912         return NULL_TREE;
8913
8914       src_align = get_pointer_alignment (src);
8915       dest_align = get_pointer_alignment (dest);
8916       if (dest_align < TYPE_ALIGN (desttype)
8917           || src_align < TYPE_ALIGN (srctype))
8918         return NULL_TREE;
8919
8920       if (!ignore)
8921         dest = builtin_save_expr (dest);
8922
8923       /* Build accesses at offset zero with a ref-all character type.  */
8924       off0 = build_int_cst (build_pointer_type_for_mode (char_type_node,
8925                                                          ptr_mode, true), 0);
8926
8927       destvar = dest;
8928       STRIP_NOPS (destvar);
8929       if (TREE_CODE (destvar) == ADDR_EXPR
8930           && var_decl_component_p (TREE_OPERAND (destvar, 0))
8931           && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8932         destvar = fold_build2 (MEM_REF, desttype, destvar, off0);
8933       else
8934         destvar = NULL_TREE;
8935
8936       srcvar = src;
8937       STRIP_NOPS (srcvar);
8938       if (TREE_CODE (srcvar) == ADDR_EXPR
8939           && var_decl_component_p (TREE_OPERAND (srcvar, 0))
8940           && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8941         {
8942           if (!destvar
8943               || src_align >= TYPE_ALIGN (desttype))
8944             srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype,
8945                                   srcvar, off0);
8946           else if (!STRICT_ALIGNMENT)
8947             {
8948               srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8949                                             src_align);
8950               srcvar = fold_build2 (MEM_REF, srctype, srcvar, off0);
8951             }
8952           else
8953             srcvar = NULL_TREE;
8954         }
8955       else
8956         srcvar = NULL_TREE;
8957
8958       if (srcvar == NULL_TREE && destvar == NULL_TREE)
8959         return NULL_TREE;
8960
8961       if (srcvar == NULL_TREE)
8962         {
8963           STRIP_NOPS (src);
8964           if (src_align >= TYPE_ALIGN (desttype))
8965             srcvar = fold_build2 (MEM_REF, desttype, src, off0);
8966           else
8967             {
8968               if (STRICT_ALIGNMENT)
8969                 return NULL_TREE;
8970               srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8971                                             src_align);
8972               srcvar = fold_build2 (MEM_REF, srctype, src, off0);
8973             }
8974         }
8975       else if (destvar == NULL_TREE)
8976         {
8977           STRIP_NOPS (dest);
8978           if (dest_align >= TYPE_ALIGN (srctype))
8979             destvar = fold_build2 (MEM_REF, srctype, dest, off0);
8980           else
8981             {
8982               if (STRICT_ALIGNMENT)
8983                 return NULL_TREE;
8984               desttype = build_aligned_type (TYPE_MAIN_VARIANT (srctype),
8985                                              dest_align);
8986               destvar = fold_build2 (MEM_REF, desttype, dest, off0);
8987             }
8988         }
8989
8990       expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, srcvar);
8991     }
8992
8993   if (ignore)
8994     return expr;
8995
8996   if (endp == 0 || endp == 3)
8997     return omit_one_operand_loc (loc, type, dest, expr);
8998
8999   if (expr == len)
9000     expr = NULL_TREE;
9001
9002   if (endp == 2)
9003     len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
9004                        ssize_int (1));
9005
9006   dest = fold_build_pointer_plus_loc (loc, dest, len);
9007   dest = fold_convert_loc (loc, type, dest);
9008   if (expr)
9009     dest = omit_one_operand_loc (loc, type, dest, expr);
9010   return dest;
9011 }
9012
9013 /* Fold function call to builtin strcpy with arguments DEST and SRC.
9014    If LEN is not NULL, it represents the length of the string to be
9015    copied.  Return NULL_TREE if no simplification can be made.  */
9016
9017 tree
9018 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
9019 {
9020   tree fn;
9021
9022   if (!validate_arg (dest, POINTER_TYPE)
9023       || !validate_arg (src, POINTER_TYPE))
9024     return NULL_TREE;
9025
9026   /* If SRC and DEST are the same (and not volatile), return DEST.  */
9027   if (operand_equal_p (src, dest, 0))
9028     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
9029
9030   if (optimize_function_for_size_p (cfun))
9031     return NULL_TREE;
9032
9033   fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
9034   if (!fn)
9035     return NULL_TREE;
9036
9037   if (!len)
9038     {
9039       len = c_strlen (src, 1);
9040       if (! len || TREE_SIDE_EFFECTS (len))
9041         return NULL_TREE;
9042     }
9043
9044   len = fold_convert_loc (loc, size_type_node, len);
9045   len = size_binop_loc (loc, PLUS_EXPR, len, build_int_cst (size_type_node, 1));
9046   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
9047                            build_call_expr_loc (loc, fn, 3, dest, src, len));
9048 }
9049
9050 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
9051    Return NULL_TREE if no simplification can be made.  */
9052
9053 static tree
9054 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
9055 {
9056   tree fn, len, lenp1, call, type;
9057
9058   if (!validate_arg (dest, POINTER_TYPE)
9059       || !validate_arg (src, POINTER_TYPE))
9060     return NULL_TREE;
9061
9062   len = c_strlen (src, 1);
9063   if (!len
9064       || TREE_CODE (len) != INTEGER_CST)
9065     return NULL_TREE;
9066
9067   if (optimize_function_for_size_p (cfun)
9068       /* If length is zero it's small enough.  */
9069       && !integer_zerop (len))
9070     return NULL_TREE;
9071
9072   fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
9073   if (!fn)
9074     return NULL_TREE;
9075
9076   lenp1 = size_binop_loc (loc, PLUS_EXPR,
9077                           fold_convert_loc (loc, size_type_node, len),
9078                           build_int_cst (size_type_node, 1));
9079   /* We use dest twice in building our expression.  Save it from
9080      multiple expansions.  */
9081   dest = builtin_save_expr (dest);
9082   call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
9083
9084   type = TREE_TYPE (TREE_TYPE (fndecl));
9085   dest = fold_build_pointer_plus_loc (loc, dest, len);
9086   dest = fold_convert_loc (loc, type, dest);
9087   dest = omit_one_operand_loc (loc, type, dest, call);
9088   return dest;
9089 }
9090
9091 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
9092    If SLEN is not NULL, it represents the length of the source string.
9093    Return NULL_TREE if no simplification can be made.  */
9094
9095 tree
9096 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
9097                       tree src, tree len, tree slen)
9098 {
9099   tree fn;
9100
9101   if (!validate_arg (dest, POINTER_TYPE)
9102       || !validate_arg (src, POINTER_TYPE)
9103       || !validate_arg (len, INTEGER_TYPE))
9104     return NULL_TREE;
9105
9106   /* If the LEN parameter is zero, return DEST.  */
9107   if (integer_zerop (len))
9108     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
9109
9110   /* We can't compare slen with len as constants below if len is not a
9111      constant.  */
9112   if (len == 0 || TREE_CODE (len) != INTEGER_CST)
9113     return NULL_TREE;
9114
9115   if (!slen)
9116     slen = c_strlen (src, 1);
9117
9118   /* Now, we must be passed a constant src ptr parameter.  */
9119   if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
9120     return NULL_TREE;
9121
9122   slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
9123
9124   /* We do not support simplification of this case, though we do
9125      support it when expanding trees into RTL.  */
9126   /* FIXME: generate a call to __builtin_memset.  */
9127   if (tree_int_cst_lt (slen, len))
9128     return NULL_TREE;
9129
9130   /* OK transform into builtin memcpy.  */
9131   fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
9132   if (!fn)
9133     return NULL_TREE;
9134
9135   len = fold_convert_loc (loc, size_type_node, len);
9136   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
9137                            build_call_expr_loc (loc, fn, 3, dest, src, len));
9138 }
9139
9140 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
9141    arguments to the call, and TYPE is its return type.
9142    Return NULL_TREE if no simplification can be made.  */
9143
9144 static tree
9145 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
9146 {
9147   if (!validate_arg (arg1, POINTER_TYPE)
9148       || !validate_arg (arg2, INTEGER_TYPE)
9149       || !validate_arg (len, INTEGER_TYPE))
9150     return NULL_TREE;
9151   else
9152     {
9153       const char *p1;
9154
9155       if (TREE_CODE (arg2) != INTEGER_CST
9156           || !host_integerp (len, 1))
9157         return NULL_TREE;
9158
9159       p1 = c_getstr (arg1);
9160       if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
9161         {
9162           char c;
9163           const char *r;
9164           tree tem;
9165
9166           if (target_char_cast (arg2, &c))
9167             return NULL_TREE;
9168
9169           r = (const char *) memchr (p1, c, tree_low_cst (len, 1));
9170
9171           if (r == NULL)
9172             return build_int_cst (TREE_TYPE (arg1), 0);
9173
9174           tem = fold_build_pointer_plus_hwi_loc (loc, arg1, r - p1);
9175           return fold_convert_loc (loc, type, tem);
9176         }
9177       return NULL_TREE;
9178     }
9179 }
9180
9181 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
9182    Return NULL_TREE if no simplification can be made.  */
9183
9184 static tree
9185 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
9186 {
9187   const char *p1, *p2;
9188
9189   if (!validate_arg (arg1, POINTER_TYPE)
9190       || !validate_arg (arg2, POINTER_TYPE)
9191       || !validate_arg (len, INTEGER_TYPE))
9192     return NULL_TREE;
9193
9194   /* If the LEN parameter is zero, return zero.  */
9195   if (integer_zerop (len))
9196     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
9197                               arg1, arg2);
9198
9199   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
9200   if (operand_equal_p (arg1, arg2, 0))
9201     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
9202
9203   p1 = c_getstr (arg1);
9204   p2 = c_getstr (arg2);
9205
9206   /* If all arguments are constant, and the value of len is not greater
9207      than the lengths of arg1 and arg2, evaluate at compile-time.  */
9208   if (host_integerp (len, 1) && p1 && p2
9209       && compare_tree_int (len, strlen (p1) + 1) <= 0
9210       && compare_tree_int (len, strlen (p2) + 1) <= 0)
9211     {
9212       const int r = memcmp (p1, p2, tree_low_cst (len, 1));
9213
9214       if (r > 0)
9215         return integer_one_node;
9216       else if (r < 0)
9217         return integer_minus_one_node;
9218       else
9219         return integer_zero_node;
9220     }
9221
9222   /* If len parameter is one, return an expression corresponding to
9223      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
9224   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9225     {
9226       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9227       tree cst_uchar_ptr_node
9228         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9229
9230       tree ind1
9231         = fold_convert_loc (loc, integer_type_node,
9232                             build1 (INDIRECT_REF, cst_uchar_node,
9233                                     fold_convert_loc (loc,
9234                                                       cst_uchar_ptr_node,
9235                                                       arg1)));
9236       tree ind2
9237         = fold_convert_loc (loc, integer_type_node,
9238                             build1 (INDIRECT_REF, cst_uchar_node,
9239                                     fold_convert_loc (loc,
9240                                                       cst_uchar_ptr_node,
9241                                                       arg2)));
9242       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9243     }
9244
9245   return NULL_TREE;
9246 }
9247
9248 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
9249    Return NULL_TREE if no simplification can be made.  */
9250
9251 static tree
9252 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
9253 {
9254   const char *p1, *p2;
9255
9256   if (!validate_arg (arg1, POINTER_TYPE)
9257       || !validate_arg (arg2, POINTER_TYPE))
9258     return NULL_TREE;
9259
9260   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
9261   if (operand_equal_p (arg1, arg2, 0))
9262     return integer_zero_node;
9263
9264   p1 = c_getstr (arg1);
9265   p2 = c_getstr (arg2);
9266
9267   if (p1 && p2)
9268     {
9269       const int i = strcmp (p1, p2);
9270       if (i < 0)
9271         return integer_minus_one_node;
9272       else if (i > 0)
9273         return integer_one_node;
9274       else
9275         return integer_zero_node;
9276     }
9277
9278   /* If the second arg is "", return *(const unsigned char*)arg1.  */
9279   if (p2 && *p2 == '\0')
9280     {
9281       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9282       tree cst_uchar_ptr_node
9283         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9284
9285       return fold_convert_loc (loc, integer_type_node,
9286                                build1 (INDIRECT_REF, cst_uchar_node,
9287                                        fold_convert_loc (loc,
9288                                                          cst_uchar_ptr_node,
9289                                                          arg1)));
9290     }
9291
9292   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
9293   if (p1 && *p1 == '\0')
9294     {
9295       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9296       tree cst_uchar_ptr_node
9297         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9298
9299       tree temp
9300         = fold_convert_loc (loc, integer_type_node,
9301                             build1 (INDIRECT_REF, cst_uchar_node,
9302                                     fold_convert_loc (loc,
9303                                                       cst_uchar_ptr_node,
9304                                                       arg2)));
9305       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9306     }
9307
9308   return NULL_TREE;
9309 }
9310
9311 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
9312    Return NULL_TREE if no simplification can be made.  */
9313
9314 static tree
9315 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
9316 {
9317   const char *p1, *p2;
9318
9319   if (!validate_arg (arg1, POINTER_TYPE)
9320       || !validate_arg (arg2, POINTER_TYPE)
9321       || !validate_arg (len, INTEGER_TYPE))
9322     return NULL_TREE;
9323
9324   /* If the LEN parameter is zero, return zero.  */
9325   if (integer_zerop (len))
9326     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
9327                               arg1, arg2);
9328
9329   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
9330   if (operand_equal_p (arg1, arg2, 0))
9331     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
9332
9333   p1 = c_getstr (arg1);
9334   p2 = c_getstr (arg2);
9335
9336   if (host_integerp (len, 1) && p1 && p2)
9337     {
9338       const int i = strncmp (p1, p2, tree_low_cst (len, 1));
9339       if (i > 0)
9340         return integer_one_node;
9341       else if (i < 0)
9342         return integer_minus_one_node;
9343       else
9344         return integer_zero_node;
9345     }
9346
9347   /* If the second arg is "", and the length is greater than zero,
9348      return *(const unsigned char*)arg1.  */
9349   if (p2 && *p2 == '\0'
9350       && TREE_CODE (len) == INTEGER_CST
9351       && tree_int_cst_sgn (len) == 1)
9352     {
9353       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9354       tree cst_uchar_ptr_node
9355         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9356
9357       return fold_convert_loc (loc, integer_type_node,
9358                                build1 (INDIRECT_REF, cst_uchar_node,
9359                                        fold_convert_loc (loc,
9360                                                          cst_uchar_ptr_node,
9361                                                          arg1)));
9362     }
9363
9364   /* If the first arg is "", and the length is greater than zero,
9365      return -*(const unsigned char*)arg2.  */
9366   if (p1 && *p1 == '\0'
9367       && TREE_CODE (len) == INTEGER_CST
9368       && tree_int_cst_sgn (len) == 1)
9369     {
9370       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9371       tree cst_uchar_ptr_node
9372         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9373
9374       tree temp = fold_convert_loc (loc, integer_type_node,
9375                                     build1 (INDIRECT_REF, cst_uchar_node,
9376                                             fold_convert_loc (loc,
9377                                                               cst_uchar_ptr_node,
9378                                                               arg2)));
9379       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9380     }
9381
9382   /* If len parameter is one, return an expression corresponding to
9383      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
9384   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9385     {
9386       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9387       tree cst_uchar_ptr_node
9388         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9389
9390       tree ind1 = fold_convert_loc (loc, integer_type_node,
9391                                     build1 (INDIRECT_REF, cst_uchar_node,
9392                                             fold_convert_loc (loc,
9393                                                               cst_uchar_ptr_node,
9394                                                               arg1)));
9395       tree ind2 = fold_convert_loc (loc, integer_type_node,
9396                                     build1 (INDIRECT_REF, cst_uchar_node,
9397                                             fold_convert_loc (loc,
9398                                                               cst_uchar_ptr_node,
9399                                                               arg2)));
9400       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9401     }
9402
9403   return NULL_TREE;
9404 }
9405
9406 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9407    ARG.  Return NULL_TREE if no simplification can be made.  */
9408
9409 static tree
9410 fold_builtin_signbit (location_t loc, tree arg, tree type)
9411 {
9412   if (!validate_arg (arg, REAL_TYPE))
9413     return NULL_TREE;
9414
9415   /* If ARG is a compile-time constant, determine the result.  */
9416   if (TREE_CODE (arg) == REAL_CST
9417       && !TREE_OVERFLOW (arg))
9418     {
9419       REAL_VALUE_TYPE c;
9420
9421       c = TREE_REAL_CST (arg);
9422       return (REAL_VALUE_NEGATIVE (c)
9423               ? build_one_cst (type)
9424               : build_zero_cst (type));
9425     }
9426
9427   /* If ARG is non-negative, the result is always zero.  */
9428   if (tree_expr_nonnegative_p (arg))
9429     return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9430
9431   /* If ARG's format doesn't have signed zeros, return "arg < 0.0".  */
9432   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9433     return fold_convert (type,
9434                          fold_build2_loc (loc, LT_EXPR, boolean_type_node, arg,
9435                         build_real (TREE_TYPE (arg), dconst0)));
9436
9437   return NULL_TREE;
9438 }
9439
9440 /* Fold function call to builtin copysign, copysignf or copysignl with
9441    arguments ARG1 and ARG2.  Return NULL_TREE if no simplification can
9442    be made.  */
9443
9444 static tree
9445 fold_builtin_copysign (location_t loc, tree fndecl,
9446                        tree arg1, tree arg2, tree type)
9447 {
9448   tree tem;
9449
9450   if (!validate_arg (arg1, REAL_TYPE)
9451       || !validate_arg (arg2, REAL_TYPE))
9452     return NULL_TREE;
9453
9454   /* copysign(X,X) is X.  */
9455   if (operand_equal_p (arg1, arg2, 0))
9456     return fold_convert_loc (loc, type, arg1);
9457
9458   /* If ARG1 and ARG2 are compile-time constants, determine the result.  */
9459   if (TREE_CODE (arg1) == REAL_CST
9460       && TREE_CODE (arg2) == REAL_CST
9461       && !TREE_OVERFLOW (arg1)
9462       && !TREE_OVERFLOW (arg2))
9463     {
9464       REAL_VALUE_TYPE c1, c2;
9465
9466       c1 = TREE_REAL_CST (arg1);
9467       c2 = TREE_REAL_CST (arg2);
9468       /* c1.sign := c2.sign.  */
9469       real_copysign (&c1, &c2);
9470       return build_real (type, c1);
9471     }
9472
9473   /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9474      Remember to evaluate Y for side-effects.  */
9475   if (tree_expr_nonnegative_p (arg2))
9476     return omit_one_operand_loc (loc, type,
9477                              fold_build1_loc (loc, ABS_EXPR, type, arg1),
9478                              arg2);
9479
9480   /* Strip sign changing operations for the first argument.  */
9481   tem = fold_strip_sign_ops (arg1);
9482   if (tem)
9483     return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9484
9485   return NULL_TREE;
9486 }
9487
9488 /* Fold a call to builtin isascii with argument ARG.  */
9489
9490 static tree
9491 fold_builtin_isascii (location_t loc, tree arg)
9492 {
9493   if (!validate_arg (arg, INTEGER_TYPE))
9494     return NULL_TREE;
9495   else
9496     {
9497       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
9498       arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9499                          build_int_cst (integer_type_node,
9500                                         ~ (unsigned HOST_WIDE_INT) 0x7f));
9501       return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9502                               arg, integer_zero_node);
9503     }
9504 }
9505
9506 /* Fold a call to builtin toascii with argument ARG.  */
9507
9508 static tree
9509 fold_builtin_toascii (location_t loc, tree arg)
9510 {
9511   if (!validate_arg (arg, INTEGER_TYPE))
9512     return NULL_TREE;
9513
9514   /* Transform toascii(c) -> (c & 0x7f).  */
9515   return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9516                           build_int_cst (integer_type_node, 0x7f));
9517 }
9518
9519 /* Fold a call to builtin isdigit with argument ARG.  */
9520
9521 static tree
9522 fold_builtin_isdigit (location_t loc, tree arg)
9523 {
9524   if (!validate_arg (arg, INTEGER_TYPE))
9525     return NULL_TREE;
9526   else
9527     {
9528       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
9529       /* According to the C standard, isdigit is unaffected by locale.
9530          However, it definitely is affected by the target character set.  */
9531       unsigned HOST_WIDE_INT target_digit0
9532         = lang_hooks.to_target_charset ('0');
9533
9534       if (target_digit0 == 0)
9535         return NULL_TREE;
9536
9537       arg = fold_convert_loc (loc, unsigned_type_node, arg);
9538       arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9539                          build_int_cst (unsigned_type_node, target_digit0));
9540       return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9541                           build_int_cst (unsigned_type_node, 9));
9542     }
9543 }
9544
9545 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
9546
9547 static tree
9548 fold_builtin_fabs (location_t loc, tree arg, tree type)
9549 {
9550   if (!validate_arg (arg, REAL_TYPE))
9551     return NULL_TREE;
9552
9553   arg = fold_convert_loc (loc, type, arg);
9554   if (TREE_CODE (arg) == REAL_CST)
9555     return fold_abs_const (arg, type);
9556   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9557 }
9558
9559 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
9560
9561 static tree
9562 fold_builtin_abs (location_t loc, tree arg, tree type)
9563 {
9564   if (!validate_arg (arg, INTEGER_TYPE))
9565     return NULL_TREE;
9566
9567   arg = fold_convert_loc (loc, type, arg);
9568   if (TREE_CODE (arg) == INTEGER_CST)
9569     return fold_abs_const (arg, type);
9570   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9571 }
9572
9573 /* Fold a fma operation with arguments ARG[012].  */
9574
9575 tree
9576 fold_fma (location_t loc ATTRIBUTE_UNUSED,
9577           tree type, tree arg0, tree arg1, tree arg2)
9578 {
9579   if (TREE_CODE (arg0) == REAL_CST
9580       && TREE_CODE (arg1) == REAL_CST
9581       && TREE_CODE (arg2) == REAL_CST)
9582     return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
9583
9584   return NULL_TREE;
9585 }
9586
9587 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012].  */
9588
9589 static tree
9590 fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type)
9591 {
9592   if (validate_arg (arg0, REAL_TYPE)
9593       && validate_arg(arg1, REAL_TYPE)
9594       && validate_arg(arg2, REAL_TYPE))
9595     {
9596       tree tem = fold_fma (loc, type, arg0, arg1, arg2);
9597       if (tem)
9598         return tem;
9599
9600       /* ??? Only expand to FMA_EXPR if it's directly supported.  */
9601       if (optab_handler (fma_optab, TYPE_MODE (type)) != CODE_FOR_nothing)
9602         return fold_build3_loc (loc, FMA_EXPR, type, arg0, arg1, arg2);
9603     }
9604   return NULL_TREE;
9605 }
9606
9607 /* Fold a call to builtin fmin or fmax.  */
9608
9609 static tree
9610 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9611                         tree type, bool max)
9612 {
9613   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9614     {
9615       /* Calculate the result when the argument is a constant.  */
9616       tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9617
9618       if (res)
9619         return res;
9620
9621       /* If either argument is NaN, return the other one.  Avoid the
9622          transformation if we get (and honor) a signalling NaN.  Using
9623          omit_one_operand() ensures we create a non-lvalue.  */
9624       if (TREE_CODE (arg0) == REAL_CST
9625           && real_isnan (&TREE_REAL_CST (arg0))
9626           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9627               || ! TREE_REAL_CST (arg0).signalling))
9628         return omit_one_operand_loc (loc, type, arg1, arg0);
9629       if (TREE_CODE (arg1) == REAL_CST
9630           && real_isnan (&TREE_REAL_CST (arg1))
9631           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9632               || ! TREE_REAL_CST (arg1).signalling))
9633         return omit_one_operand_loc (loc, type, arg0, arg1);
9634
9635       /* Transform fmin/fmax(x,x) -> x.  */
9636       if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9637         return omit_one_operand_loc (loc, type, arg0, arg1);
9638
9639       /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR.  C99 requires these
9640          functions to return the numeric arg if the other one is NaN.
9641          These tree codes don't honor that, so only transform if
9642          -ffinite-math-only is set.  C99 doesn't require -0.0 to be
9643          handled, so we don't have to worry about it either.  */
9644       if (flag_finite_math_only)
9645         return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9646                             fold_convert_loc (loc, type, arg0),
9647                             fold_convert_loc (loc, type, arg1));
9648     }
9649   return NULL_TREE;
9650 }
9651
9652 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
9653
9654 static tree
9655 fold_builtin_carg (location_t loc, tree arg, tree type)
9656 {
9657   if (validate_arg (arg, COMPLEX_TYPE)
9658       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9659     {
9660       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9661
9662       if (atan2_fn)
9663         {
9664           tree new_arg = builtin_save_expr (arg);
9665           tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9666           tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9667           return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9668         }
9669     }
9670
9671   return NULL_TREE;
9672 }
9673
9674 /* Fold a call to builtin logb/ilogb.  */
9675
9676 static tree
9677 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9678 {
9679   if (! validate_arg (arg, REAL_TYPE))
9680     return NULL_TREE;
9681
9682   STRIP_NOPS (arg);
9683
9684   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9685     {
9686       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9687
9688       switch (value->cl)
9689       {
9690       case rvc_nan:
9691       case rvc_inf:
9692         /* If arg is Inf or NaN and we're logb, return it.  */
9693         if (TREE_CODE (rettype) == REAL_TYPE)
9694           return fold_convert_loc (loc, rettype, arg);
9695         /* Fall through... */
9696       case rvc_zero:
9697         /* Zero may set errno and/or raise an exception for logb, also
9698            for ilogb we don't know FP_ILOGB0.  */
9699         return NULL_TREE;
9700       case rvc_normal:
9701         /* For normal numbers, proceed iff radix == 2.  In GCC,
9702            normalized significands are in the range [0.5, 1.0).  We
9703            want the exponent as if they were [1.0, 2.0) so get the
9704            exponent and subtract 1.  */
9705         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9706           return fold_convert_loc (loc, rettype,
9707                                    build_int_cst (integer_type_node,
9708                                                   REAL_EXP (value)-1));
9709         break;
9710       }
9711     }
9712
9713   return NULL_TREE;
9714 }
9715
9716 /* Fold a call to builtin significand, if radix == 2.  */
9717
9718 static tree
9719 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9720 {
9721   if (! validate_arg (arg, REAL_TYPE))
9722     return NULL_TREE;
9723
9724   STRIP_NOPS (arg);
9725
9726   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9727     {
9728       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9729
9730       switch (value->cl)
9731       {
9732       case rvc_zero:
9733       case rvc_nan:
9734       case rvc_inf:
9735         /* If arg is +-0, +-Inf or +-NaN, then return it.  */
9736         return fold_convert_loc (loc, rettype, arg);
9737       case rvc_normal:
9738         /* For normal numbers, proceed iff radix == 2.  */
9739         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9740           {
9741             REAL_VALUE_TYPE result = *value;
9742             /* In GCC, normalized significands are in the range [0.5,
9743                1.0).  We want them to be [1.0, 2.0) so set the
9744                exponent to 1.  */
9745             SET_REAL_EXP (&result, 1);
9746             return build_real (rettype, result);
9747           }
9748         break;
9749       }
9750     }
9751
9752   return NULL_TREE;
9753 }
9754
9755 /* Fold a call to builtin frexp, we can assume the base is 2.  */
9756
9757 static tree
9758 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9759 {
9760   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9761     return NULL_TREE;
9762
9763   STRIP_NOPS (arg0);
9764
9765   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9766     return NULL_TREE;
9767
9768   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9769
9770   /* Proceed if a valid pointer type was passed in.  */
9771   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9772     {
9773       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9774       tree frac, exp;
9775
9776       switch (value->cl)
9777       {
9778       case rvc_zero:
9779         /* For +-0, return (*exp = 0, +-0).  */
9780         exp = integer_zero_node;
9781         frac = arg0;
9782         break;
9783       case rvc_nan:
9784       case rvc_inf:
9785         /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
9786         return omit_one_operand_loc (loc, rettype, arg0, arg1);
9787       case rvc_normal:
9788         {
9789           /* Since the frexp function always expects base 2, and in
9790              GCC normalized significands are already in the range
9791              [0.5, 1.0), we have exactly what frexp wants.  */
9792           REAL_VALUE_TYPE frac_rvt = *value;
9793           SET_REAL_EXP (&frac_rvt, 0);
9794           frac = build_real (rettype, frac_rvt);
9795           exp = build_int_cst (integer_type_node, REAL_EXP (value));
9796         }
9797         break;
9798       default:
9799         gcc_unreachable ();
9800       }
9801
9802       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9803       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9804       TREE_SIDE_EFFECTS (arg1) = 1;
9805       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9806     }
9807
9808   return NULL_TREE;
9809 }
9810
9811 /* Fold a call to builtin ldexp or scalbn/scalbln.  If LDEXP is true
9812    then we can assume the base is two.  If it's false, then we have to
9813    check the mode of the TYPE parameter in certain cases.  */
9814
9815 static tree
9816 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9817                             tree type, bool ldexp)
9818 {
9819   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9820     {
9821       STRIP_NOPS (arg0);
9822       STRIP_NOPS (arg1);
9823
9824       /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0.  */
9825       if (real_zerop (arg0) || integer_zerop (arg1)
9826           || (TREE_CODE (arg0) == REAL_CST
9827               && !real_isfinite (&TREE_REAL_CST (arg0))))
9828         return omit_one_operand_loc (loc, type, arg0, arg1);
9829
9830       /* If both arguments are constant, then try to evaluate it.  */
9831       if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9832           && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9833           && host_integerp (arg1, 0))
9834         {
9835           /* Bound the maximum adjustment to twice the range of the
9836              mode's valid exponents.  Use abs to ensure the range is
9837              positive as a sanity check.  */
9838           const long max_exp_adj = 2 *
9839             labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9840                  - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9841
9842           /* Get the user-requested adjustment.  */
9843           const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9844
9845           /* The requested adjustment must be inside this range.  This
9846              is a preliminary cap to avoid things like overflow, we
9847              may still fail to compute the result for other reasons.  */
9848           if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9849             {
9850               REAL_VALUE_TYPE initial_result;
9851
9852               real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9853
9854               /* Ensure we didn't overflow.  */
9855               if (! real_isinf (&initial_result))
9856                 {
9857                   const REAL_VALUE_TYPE trunc_result
9858                     = real_value_truncate (TYPE_MODE (type), initial_result);
9859
9860                   /* Only proceed if the target mode can hold the
9861                      resulting value.  */
9862                   if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9863                     return build_real (type, trunc_result);
9864                 }
9865             }
9866         }
9867     }
9868
9869   return NULL_TREE;
9870 }
9871
9872 /* Fold a call to builtin modf.  */
9873
9874 static tree
9875 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9876 {
9877   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9878     return NULL_TREE;
9879
9880   STRIP_NOPS (arg0);
9881
9882   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9883     return NULL_TREE;
9884
9885   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9886
9887   /* Proceed if a valid pointer type was passed in.  */
9888   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9889     {
9890       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9891       REAL_VALUE_TYPE trunc, frac;
9892
9893       switch (value->cl)
9894       {
9895       case rvc_nan:
9896       case rvc_zero:
9897         /* For +-NaN or +-0, return (*arg1 = arg0, arg0).  */
9898         trunc = frac = *value;
9899         break;
9900       case rvc_inf:
9901         /* For +-Inf, return (*arg1 = arg0, +-0).  */
9902         frac = dconst0;
9903         frac.sign = value->sign;
9904         trunc = *value;
9905         break;
9906       case rvc_normal:
9907         /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)).  */
9908         real_trunc (&trunc, VOIDmode, value);
9909         real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9910         /* If the original number was negative and already
9911            integral, then the fractional part is -0.0.  */
9912         if (value->sign && frac.cl == rvc_zero)
9913           frac.sign = value->sign;
9914         break;
9915       }
9916
9917       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9918       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9919                           build_real (rettype, trunc));
9920       TREE_SIDE_EFFECTS (arg1) = 1;
9921       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9922                           build_real (rettype, frac));
9923     }
9924
9925   return NULL_TREE;
9926 }
9927
9928 /* Given a location LOC, an interclass builtin function decl FNDECL
9929    and its single argument ARG, return an folded expression computing
9930    the same, or NULL_TREE if we either couldn't or didn't want to fold
9931    (the latter happen if there's an RTL instruction available).  */
9932
9933 static tree
9934 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9935 {
9936   enum machine_mode mode;
9937
9938   if (!validate_arg (arg, REAL_TYPE))
9939     return NULL_TREE;
9940
9941   if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9942     return NULL_TREE;
9943
9944   mode = TYPE_MODE (TREE_TYPE (arg));
9945
9946   /* If there is no optab, try generic code.  */
9947   switch (DECL_FUNCTION_CODE (fndecl))
9948     {
9949       tree result;
9950
9951     CASE_FLT_FN (BUILT_IN_ISINF):
9952       {
9953         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
9954         tree const isgr_fn = builtin_decl_explicit (BUILT_IN_ISGREATER);
9955         tree const type = TREE_TYPE (arg);
9956         REAL_VALUE_TYPE r;
9957         char buf[128];
9958
9959         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9960         real_from_string (&r, buf);
9961         result = build_call_expr (isgr_fn, 2,
9962                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9963                                   build_real (type, r));
9964         return result;
9965       }
9966     CASE_FLT_FN (BUILT_IN_FINITE):
9967     case BUILT_IN_ISFINITE:
9968       {
9969         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
9970         tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
9971         tree const type = TREE_TYPE (arg);
9972         REAL_VALUE_TYPE r;
9973         char buf[128];
9974
9975         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9976         real_from_string (&r, buf);
9977         result = build_call_expr (isle_fn, 2,
9978                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9979                                   build_real (type, r));
9980         /*result = fold_build2_loc (loc, UNGT_EXPR,
9981                                   TREE_TYPE (TREE_TYPE (fndecl)),
9982                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9983                                   build_real (type, r));
9984         result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9985                                   TREE_TYPE (TREE_TYPE (fndecl)),
9986                                   result);*/
9987         return result;
9988       }
9989     case BUILT_IN_ISNORMAL:
9990       {
9991         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9992            islessequal(fabs(x),DBL_MAX).  */
9993         tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
9994         tree const isge_fn = builtin_decl_explicit (BUILT_IN_ISGREATEREQUAL);
9995         tree const type = TREE_TYPE (arg);
9996         REAL_VALUE_TYPE rmax, rmin;
9997         char buf[128];
9998
9999         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
10000         real_from_string (&rmax, buf);
10001         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
10002         real_from_string (&rmin, buf);
10003         arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
10004         result = build_call_expr (isle_fn, 2, arg,
10005                                   build_real (type, rmax));
10006         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
10007                               build_call_expr (isge_fn, 2, arg,
10008                                                build_real (type, rmin)));
10009         return result;
10010       }
10011     default:
10012       break;
10013     }
10014
10015   return NULL_TREE;
10016 }
10017
10018 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
10019    ARG is the argument for the call.  */
10020
10021 static tree
10022 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
10023 {
10024   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10025   REAL_VALUE_TYPE r;
10026
10027   if (!validate_arg (arg, REAL_TYPE))
10028     return NULL_TREE;
10029
10030   switch (builtin_index)
10031     {
10032     case BUILT_IN_ISINF:
10033       if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
10034         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
10035
10036       if (TREE_CODE (arg) == REAL_CST)
10037         {
10038           r = TREE_REAL_CST (arg);
10039           if (real_isinf (&r))
10040             return real_compare (GT_EXPR, &r, &dconst0)
10041                    ? integer_one_node : integer_minus_one_node;
10042           else
10043             return integer_zero_node;
10044         }
10045
10046       return NULL_TREE;
10047
10048     case BUILT_IN_ISINF_SIGN:
10049       {
10050         /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
10051         /* In a boolean context, GCC will fold the inner COND_EXPR to
10052            1.  So e.g. "if (isinf_sign(x))" would be folded to just
10053            "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
10054         tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
10055         tree isinf_fn = builtin_decl_explicit (BUILT_IN_ISINF);
10056         tree tmp = NULL_TREE;
10057
10058         arg = builtin_save_expr (arg);
10059
10060         if (signbit_fn && isinf_fn)
10061           {
10062             tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
10063             tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
10064
10065             signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
10066                                         signbit_call, integer_zero_node);
10067             isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
10068                                       isinf_call, integer_zero_node);
10069
10070             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
10071                                integer_minus_one_node, integer_one_node);
10072             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
10073                                isinf_call, tmp,
10074                                integer_zero_node);
10075           }
10076
10077         return tmp;
10078       }
10079
10080     case BUILT_IN_ISFINITE:
10081       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
10082           && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
10083         return omit_one_operand_loc (loc, type, integer_one_node, arg);
10084
10085       if (TREE_CODE (arg) == REAL_CST)
10086         {
10087           r = TREE_REAL_CST (arg);
10088           return real_isfinite (&r) ? integer_one_node : integer_zero_node;
10089         }
10090
10091       return NULL_TREE;
10092
10093     case BUILT_IN_ISNAN:
10094       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
10095         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
10096
10097       if (TREE_CODE (arg) == REAL_CST)
10098         {
10099           r = TREE_REAL_CST (arg);
10100           return real_isnan (&r) ? integer_one_node : integer_zero_node;
10101         }
10102
10103       arg = builtin_save_expr (arg);
10104       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
10105
10106     default:
10107       gcc_unreachable ();
10108     }
10109 }
10110
10111 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
10112    This builtin will generate code to return the appropriate floating
10113    point classification depending on the value of the floating point
10114    number passed in.  The possible return values must be supplied as
10115    int arguments to the call in the following order: FP_NAN, FP_INFINITE,
10116    FP_NORMAL, FP_SUBNORMAL and FP_ZERO.  The ellipses is for exactly
10117    one floating point argument which is "type generic".  */
10118
10119 static tree
10120 fold_builtin_fpclassify (location_t loc, tree exp)
10121 {
10122   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
10123     arg, type, res, tmp;
10124   enum machine_mode mode;
10125   REAL_VALUE_TYPE r;
10126   char buf[128];
10127
10128   /* Verify the required arguments in the original call.  */
10129   if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
10130                          INTEGER_TYPE, INTEGER_TYPE,
10131                          INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
10132     return NULL_TREE;
10133
10134   fp_nan = CALL_EXPR_ARG (exp, 0);
10135   fp_infinite = CALL_EXPR_ARG (exp, 1);
10136   fp_normal = CALL_EXPR_ARG (exp, 2);
10137   fp_subnormal = CALL_EXPR_ARG (exp, 3);
10138   fp_zero = CALL_EXPR_ARG (exp, 4);
10139   arg = CALL_EXPR_ARG (exp, 5);
10140   type = TREE_TYPE (arg);
10141   mode = TYPE_MODE (type);
10142   arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
10143
10144   /* fpclassify(x) ->
10145        isnan(x) ? FP_NAN :
10146          (fabs(x) == Inf ? FP_INFINITE :
10147            (fabs(x) >= DBL_MIN ? FP_NORMAL :
10148              (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
10149
10150   tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
10151                      build_real (type, dconst0));
10152   res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
10153                      tmp, fp_zero, fp_subnormal);
10154
10155   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
10156   real_from_string (&r, buf);
10157   tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
10158                      arg, build_real (type, r));
10159   res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
10160
10161   if (HONOR_INFINITIES (mode))
10162     {
10163       real_inf (&r);
10164       tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
10165                          build_real (type, r));
10166       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
10167                          fp_infinite, res);
10168     }
10169
10170   if (HONOR_NANS (mode))
10171     {
10172       tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
10173       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
10174     }
10175
10176   return res;
10177 }
10178
10179 /* Fold a call to an unordered comparison function such as
10180    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
10181    being called and ARG0 and ARG1 are the arguments for the call.
10182    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
10183    the opposite of the desired result.  UNORDERED_CODE is used
10184    for modes that can hold NaNs and ORDERED_CODE is used for
10185    the rest.  */
10186
10187 static tree
10188 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
10189                             enum tree_code unordered_code,
10190                             enum tree_code ordered_code)
10191 {
10192   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10193   enum tree_code code;
10194   tree type0, type1;
10195   enum tree_code code0, code1;
10196   tree cmp_type = NULL_TREE;
10197
10198   type0 = TREE_TYPE (arg0);
10199   type1 = TREE_TYPE (arg1);
10200
10201   code0 = TREE_CODE (type0);
10202   code1 = TREE_CODE (type1);
10203
10204   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
10205     /* Choose the wider of two real types.  */
10206     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
10207       ? type0 : type1;
10208   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
10209     cmp_type = type0;
10210   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
10211     cmp_type = type1;
10212
10213   arg0 = fold_convert_loc (loc, cmp_type, arg0);
10214   arg1 = fold_convert_loc (loc, cmp_type, arg1);
10215
10216   if (unordered_code == UNORDERED_EXPR)
10217     {
10218       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
10219         return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
10220       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
10221     }
10222
10223   code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
10224                                                    : ordered_code;
10225   return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
10226                       fold_build2_loc (loc, code, type, arg0, arg1));
10227 }
10228
10229 /* Fold a call to built-in function FNDECL with 0 arguments.
10230    IGNORE is true if the result of the function call is ignored.  This
10231    function returns NULL_TREE if no simplification was possible.  */
10232
10233 static tree
10234 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
10235 {
10236   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10237   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10238   switch (fcode)
10239     {
10240     CASE_FLT_FN (BUILT_IN_INF):
10241     case BUILT_IN_INFD32:
10242     case BUILT_IN_INFD64:
10243     case BUILT_IN_INFD128:
10244       return fold_builtin_inf (loc, type, true);
10245
10246     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
10247       return fold_builtin_inf (loc, type, false);
10248
10249     case BUILT_IN_CLASSIFY_TYPE:
10250       return fold_builtin_classify_type (NULL_TREE);
10251
10252     default:
10253       break;
10254     }
10255   return NULL_TREE;
10256 }
10257
10258 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
10259    IGNORE is true if the result of the function call is ignored.  This
10260    function returns NULL_TREE if no simplification was possible.  */
10261
10262 static tree
10263 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
10264 {
10265   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10266   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10267   switch (fcode)
10268     {
10269     case BUILT_IN_CONSTANT_P:
10270       {
10271         tree val = fold_builtin_constant_p (arg0);
10272
10273         /* Gimplification will pull the CALL_EXPR for the builtin out of
10274            an if condition.  When not optimizing, we'll not CSE it back.
10275            To avoid link error types of regressions, return false now.  */
10276         if (!val && !optimize)
10277           val = integer_zero_node;
10278
10279         return val;
10280       }
10281
10282     case BUILT_IN_CLASSIFY_TYPE:
10283       return fold_builtin_classify_type (arg0);
10284
10285     case BUILT_IN_STRLEN:
10286       return fold_builtin_strlen (loc, type, arg0);
10287
10288     CASE_FLT_FN (BUILT_IN_FABS):
10289       return fold_builtin_fabs (loc, arg0, type);
10290
10291     case BUILT_IN_ABS:
10292     case BUILT_IN_LABS:
10293     case BUILT_IN_LLABS:
10294     case BUILT_IN_IMAXABS:
10295       return fold_builtin_abs (loc, arg0, type);
10296
10297     CASE_FLT_FN (BUILT_IN_CONJ):
10298       if (validate_arg (arg0, COMPLEX_TYPE)
10299         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10300         return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
10301     break;
10302
10303     CASE_FLT_FN (BUILT_IN_CREAL):
10304       if (validate_arg (arg0, COMPLEX_TYPE)
10305         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10306         return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
10307     break;
10308
10309     CASE_FLT_FN (BUILT_IN_CIMAG):
10310       if (validate_arg (arg0, COMPLEX_TYPE)
10311           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10312         return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
10313     break;
10314
10315     CASE_FLT_FN (BUILT_IN_CCOS):
10316       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
10317
10318     CASE_FLT_FN (BUILT_IN_CCOSH):
10319       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
10320
10321     CASE_FLT_FN (BUILT_IN_CPROJ):
10322       return fold_builtin_cproj(loc, arg0, type);
10323
10324     CASE_FLT_FN (BUILT_IN_CSIN):
10325       if (validate_arg (arg0, COMPLEX_TYPE)
10326           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10327         return do_mpc_arg1 (arg0, type, mpc_sin);
10328     break;
10329
10330     CASE_FLT_FN (BUILT_IN_CSINH):
10331       if (validate_arg (arg0, COMPLEX_TYPE)
10332           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10333         return do_mpc_arg1 (arg0, type, mpc_sinh);
10334     break;
10335
10336     CASE_FLT_FN (BUILT_IN_CTAN):
10337       if (validate_arg (arg0, COMPLEX_TYPE)
10338           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10339         return do_mpc_arg1 (arg0, type, mpc_tan);
10340     break;
10341
10342     CASE_FLT_FN (BUILT_IN_CTANH):
10343       if (validate_arg (arg0, COMPLEX_TYPE)
10344           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10345         return do_mpc_arg1 (arg0, type, mpc_tanh);
10346     break;
10347
10348     CASE_FLT_FN (BUILT_IN_CLOG):
10349       if (validate_arg (arg0, COMPLEX_TYPE)
10350           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10351         return do_mpc_arg1 (arg0, type, mpc_log);
10352     break;
10353
10354     CASE_FLT_FN (BUILT_IN_CSQRT):
10355       if (validate_arg (arg0, COMPLEX_TYPE)
10356           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10357         return do_mpc_arg1 (arg0, type, mpc_sqrt);
10358     break;
10359
10360     CASE_FLT_FN (BUILT_IN_CASIN):
10361       if (validate_arg (arg0, COMPLEX_TYPE)
10362           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10363         return do_mpc_arg1 (arg0, type, mpc_asin);
10364     break;
10365
10366     CASE_FLT_FN (BUILT_IN_CACOS):
10367       if (validate_arg (arg0, COMPLEX_TYPE)
10368           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10369         return do_mpc_arg1 (arg0, type, mpc_acos);
10370     break;
10371
10372     CASE_FLT_FN (BUILT_IN_CATAN):
10373       if (validate_arg (arg0, COMPLEX_TYPE)
10374           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10375         return do_mpc_arg1 (arg0, type, mpc_atan);
10376     break;
10377
10378     CASE_FLT_FN (BUILT_IN_CASINH):
10379       if (validate_arg (arg0, COMPLEX_TYPE)
10380           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10381         return do_mpc_arg1 (arg0, type, mpc_asinh);
10382     break;
10383
10384     CASE_FLT_FN (BUILT_IN_CACOSH):
10385       if (validate_arg (arg0, COMPLEX_TYPE)
10386           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10387         return do_mpc_arg1 (arg0, type, mpc_acosh);
10388     break;
10389
10390     CASE_FLT_FN (BUILT_IN_CATANH):
10391       if (validate_arg (arg0, COMPLEX_TYPE)
10392           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10393         return do_mpc_arg1 (arg0, type, mpc_atanh);
10394     break;
10395
10396     CASE_FLT_FN (BUILT_IN_CABS):
10397       return fold_builtin_cabs (loc, arg0, type, fndecl);
10398
10399     CASE_FLT_FN (BUILT_IN_CARG):
10400       return fold_builtin_carg (loc, arg0, type);
10401
10402     CASE_FLT_FN (BUILT_IN_SQRT):
10403       return fold_builtin_sqrt (loc, arg0, type);
10404
10405     CASE_FLT_FN (BUILT_IN_CBRT):
10406       return fold_builtin_cbrt (loc, arg0, type);
10407
10408     CASE_FLT_FN (BUILT_IN_ASIN):
10409       if (validate_arg (arg0, REAL_TYPE))
10410         return do_mpfr_arg1 (arg0, type, mpfr_asin,
10411                              &dconstm1, &dconst1, true);
10412     break;
10413
10414     CASE_FLT_FN (BUILT_IN_ACOS):
10415       if (validate_arg (arg0, REAL_TYPE))
10416         return do_mpfr_arg1 (arg0, type, mpfr_acos,
10417                              &dconstm1, &dconst1, true);
10418     break;
10419
10420     CASE_FLT_FN (BUILT_IN_ATAN):
10421       if (validate_arg (arg0, REAL_TYPE))
10422         return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10423     break;
10424
10425     CASE_FLT_FN (BUILT_IN_ASINH):
10426       if (validate_arg (arg0, REAL_TYPE))
10427         return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10428     break;
10429
10430     CASE_FLT_FN (BUILT_IN_ACOSH):
10431       if (validate_arg (arg0, REAL_TYPE))
10432         return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10433                              &dconst1, NULL, true);
10434     break;
10435
10436     CASE_FLT_FN (BUILT_IN_ATANH):
10437       if (validate_arg (arg0, REAL_TYPE))
10438         return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10439                              &dconstm1, &dconst1, false);
10440     break;
10441
10442     CASE_FLT_FN (BUILT_IN_SIN):
10443       if (validate_arg (arg0, REAL_TYPE))
10444         return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10445     break;
10446
10447     CASE_FLT_FN (BUILT_IN_COS):
10448       return fold_builtin_cos (loc, arg0, type, fndecl);
10449
10450     CASE_FLT_FN (BUILT_IN_TAN):
10451       return fold_builtin_tan (arg0, type);
10452
10453     CASE_FLT_FN (BUILT_IN_CEXP):
10454       return fold_builtin_cexp (loc, arg0, type);
10455
10456     CASE_FLT_FN (BUILT_IN_CEXPI):
10457       if (validate_arg (arg0, REAL_TYPE))
10458         return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10459     break;
10460
10461     CASE_FLT_FN (BUILT_IN_SINH):
10462       if (validate_arg (arg0, REAL_TYPE))
10463         return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10464     break;
10465
10466     CASE_FLT_FN (BUILT_IN_COSH):
10467       return fold_builtin_cosh (loc, arg0, type, fndecl);
10468
10469     CASE_FLT_FN (BUILT_IN_TANH):
10470       if (validate_arg (arg0, REAL_TYPE))
10471         return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10472     break;
10473
10474     CASE_FLT_FN (BUILT_IN_ERF):
10475       if (validate_arg (arg0, REAL_TYPE))
10476         return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10477     break;
10478
10479     CASE_FLT_FN (BUILT_IN_ERFC):
10480       if (validate_arg (arg0, REAL_TYPE))
10481         return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10482     break;
10483
10484     CASE_FLT_FN (BUILT_IN_TGAMMA):
10485       if (validate_arg (arg0, REAL_TYPE))
10486         return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10487     break;
10488
10489     CASE_FLT_FN (BUILT_IN_EXP):
10490       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10491
10492     CASE_FLT_FN (BUILT_IN_EXP2):
10493       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10494
10495     CASE_FLT_FN (BUILT_IN_EXP10):
10496     CASE_FLT_FN (BUILT_IN_POW10):
10497       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10498
10499     CASE_FLT_FN (BUILT_IN_EXPM1):
10500       if (validate_arg (arg0, REAL_TYPE))
10501         return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10502     break;
10503
10504     CASE_FLT_FN (BUILT_IN_LOG):
10505     return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10506
10507     CASE_FLT_FN (BUILT_IN_LOG2):
10508       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10509
10510     CASE_FLT_FN (BUILT_IN_LOG10):
10511       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10512
10513     CASE_FLT_FN (BUILT_IN_LOG1P):
10514       if (validate_arg (arg0, REAL_TYPE))
10515         return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10516                              &dconstm1, NULL, false);
10517     break;
10518
10519     CASE_FLT_FN (BUILT_IN_J0):
10520       if (validate_arg (arg0, REAL_TYPE))
10521         return do_mpfr_arg1 (arg0, type, mpfr_j0,
10522                              NULL, NULL, 0);
10523     break;
10524
10525     CASE_FLT_FN (BUILT_IN_J1):
10526       if (validate_arg (arg0, REAL_TYPE))
10527         return do_mpfr_arg1 (arg0, type, mpfr_j1,
10528                              NULL, NULL, 0);
10529     break;
10530
10531     CASE_FLT_FN (BUILT_IN_Y0):
10532       if (validate_arg (arg0, REAL_TYPE))
10533         return do_mpfr_arg1 (arg0, type, mpfr_y0,
10534                              &dconst0, NULL, false);
10535     break;
10536
10537     CASE_FLT_FN (BUILT_IN_Y1):
10538       if (validate_arg (arg0, REAL_TYPE))
10539         return do_mpfr_arg1 (arg0, type, mpfr_y1,
10540                              &dconst0, NULL, false);
10541     break;
10542
10543     CASE_FLT_FN (BUILT_IN_NAN):
10544     case BUILT_IN_NAND32:
10545     case BUILT_IN_NAND64:
10546     case BUILT_IN_NAND128:
10547       return fold_builtin_nan (arg0, type, true);
10548
10549     CASE_FLT_FN (BUILT_IN_NANS):
10550       return fold_builtin_nan (arg0, type, false);
10551
10552     CASE_FLT_FN (BUILT_IN_FLOOR):
10553       return fold_builtin_floor (loc, fndecl, arg0);
10554
10555     CASE_FLT_FN (BUILT_IN_CEIL):
10556       return fold_builtin_ceil (loc, fndecl, arg0);
10557
10558     CASE_FLT_FN (BUILT_IN_TRUNC):
10559       return fold_builtin_trunc (loc, fndecl, arg0);
10560
10561     CASE_FLT_FN (BUILT_IN_ROUND):
10562       return fold_builtin_round (loc, fndecl, arg0);
10563
10564     CASE_FLT_FN (BUILT_IN_NEARBYINT):
10565     CASE_FLT_FN (BUILT_IN_RINT):
10566       return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10567
10568     CASE_FLT_FN (BUILT_IN_ICEIL):
10569     CASE_FLT_FN (BUILT_IN_LCEIL):
10570     CASE_FLT_FN (BUILT_IN_LLCEIL):
10571     CASE_FLT_FN (BUILT_IN_LFLOOR):
10572     CASE_FLT_FN (BUILT_IN_IFLOOR):
10573     CASE_FLT_FN (BUILT_IN_LLFLOOR):
10574     CASE_FLT_FN (BUILT_IN_IROUND):
10575     CASE_FLT_FN (BUILT_IN_LROUND):
10576     CASE_FLT_FN (BUILT_IN_LLROUND):
10577       return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10578
10579     CASE_FLT_FN (BUILT_IN_IRINT):
10580     CASE_FLT_FN (BUILT_IN_LRINT):
10581     CASE_FLT_FN (BUILT_IN_LLRINT):
10582       return fold_fixed_mathfn (loc, fndecl, arg0);
10583
10584     case BUILT_IN_BSWAP16:
10585     case BUILT_IN_BSWAP32:
10586     case BUILT_IN_BSWAP64:
10587       return fold_builtin_bswap (fndecl, arg0);
10588
10589     CASE_INT_FN (BUILT_IN_FFS):
10590     CASE_INT_FN (BUILT_IN_CLZ):
10591     CASE_INT_FN (BUILT_IN_CTZ):
10592     CASE_INT_FN (BUILT_IN_CLRSB):
10593     CASE_INT_FN (BUILT_IN_POPCOUNT):
10594     CASE_INT_FN (BUILT_IN_PARITY):
10595       return fold_builtin_bitop (fndecl, arg0);
10596
10597     CASE_FLT_FN (BUILT_IN_SIGNBIT):
10598       return fold_builtin_signbit (loc, arg0, type);
10599
10600     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10601       return fold_builtin_significand (loc, arg0, type);
10602
10603     CASE_FLT_FN (BUILT_IN_ILOGB):
10604     CASE_FLT_FN (BUILT_IN_LOGB):
10605       return fold_builtin_logb (loc, arg0, type);
10606
10607     case BUILT_IN_ISASCII:
10608       return fold_builtin_isascii (loc, arg0);
10609
10610     case BUILT_IN_TOASCII:
10611       return fold_builtin_toascii (loc, arg0);
10612
10613     case BUILT_IN_ISDIGIT:
10614       return fold_builtin_isdigit (loc, arg0);
10615
10616     CASE_FLT_FN (BUILT_IN_FINITE):
10617     case BUILT_IN_FINITED32:
10618     case BUILT_IN_FINITED64:
10619     case BUILT_IN_FINITED128:
10620     case BUILT_IN_ISFINITE:
10621       {
10622         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10623         if (ret)
10624           return ret;
10625         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10626       }
10627
10628     CASE_FLT_FN (BUILT_IN_ISINF):
10629     case BUILT_IN_ISINFD32:
10630     case BUILT_IN_ISINFD64:
10631     case BUILT_IN_ISINFD128:
10632       {
10633         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10634         if (ret)
10635           return ret;
10636         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10637       }
10638
10639     case BUILT_IN_ISNORMAL:
10640       return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10641
10642     case BUILT_IN_ISINF_SIGN:
10643       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10644
10645     CASE_FLT_FN (BUILT_IN_ISNAN):
10646     case BUILT_IN_ISNAND32:
10647     case BUILT_IN_ISNAND64:
10648     case BUILT_IN_ISNAND128:
10649       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10650
10651     case BUILT_IN_PRINTF:
10652     case BUILT_IN_PRINTF_UNLOCKED:
10653     case BUILT_IN_VPRINTF:
10654       return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10655
10656     case BUILT_IN_FREE:
10657       if (integer_zerop (arg0))
10658         return build_empty_stmt (loc);
10659       break;
10660
10661     default:
10662       break;
10663     }
10664
10665   return NULL_TREE;
10666
10667 }
10668
10669 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10670    IGNORE is true if the result of the function call is ignored.  This
10671    function returns NULL_TREE if no simplification was possible.  */
10672
10673 static tree
10674 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10675 {
10676   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10677   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10678
10679   switch (fcode)
10680     {
10681     CASE_FLT_FN (BUILT_IN_JN):
10682       if (validate_arg (arg0, INTEGER_TYPE)
10683           && validate_arg (arg1, REAL_TYPE))
10684         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10685     break;
10686
10687     CASE_FLT_FN (BUILT_IN_YN):
10688       if (validate_arg (arg0, INTEGER_TYPE)
10689           && validate_arg (arg1, REAL_TYPE))
10690         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10691                                  &dconst0, false);
10692     break;
10693
10694     CASE_FLT_FN (BUILT_IN_DREM):
10695     CASE_FLT_FN (BUILT_IN_REMAINDER):
10696       if (validate_arg (arg0, REAL_TYPE)
10697           && validate_arg(arg1, REAL_TYPE))
10698         return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10699     break;
10700
10701     CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10702     CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10703       if (validate_arg (arg0, REAL_TYPE)
10704           && validate_arg(arg1, POINTER_TYPE))
10705         return do_mpfr_lgamma_r (arg0, arg1, type);
10706     break;
10707
10708     CASE_FLT_FN (BUILT_IN_ATAN2):
10709       if (validate_arg (arg0, REAL_TYPE)
10710           && validate_arg(arg1, REAL_TYPE))
10711         return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10712     break;
10713
10714     CASE_FLT_FN (BUILT_IN_FDIM):
10715       if (validate_arg (arg0, REAL_TYPE)
10716           && validate_arg(arg1, REAL_TYPE))
10717         return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10718     break;
10719
10720     CASE_FLT_FN (BUILT_IN_HYPOT):
10721       return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10722
10723     CASE_FLT_FN (BUILT_IN_CPOW):
10724       if (validate_arg (arg0, COMPLEX_TYPE)
10725           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10726           && validate_arg (arg1, COMPLEX_TYPE)
10727           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10728         return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10729     break;
10730
10731     CASE_FLT_FN (BUILT_IN_LDEXP):
10732       return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10733     CASE_FLT_FN (BUILT_IN_SCALBN):
10734     CASE_FLT_FN (BUILT_IN_SCALBLN):
10735       return fold_builtin_load_exponent (loc, arg0, arg1,
10736                                          type, /*ldexp=*/false);
10737
10738     CASE_FLT_FN (BUILT_IN_FREXP):
10739       return fold_builtin_frexp (loc, arg0, arg1, type);
10740
10741     CASE_FLT_FN (BUILT_IN_MODF):
10742       return fold_builtin_modf (loc, arg0, arg1, type);
10743
10744     case BUILT_IN_BZERO:
10745       return fold_builtin_bzero (loc, arg0, arg1, ignore);
10746
10747     case BUILT_IN_FPUTS:
10748       return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10749
10750     case BUILT_IN_FPUTS_UNLOCKED:
10751       return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10752
10753     case BUILT_IN_STRSTR:
10754       return fold_builtin_strstr (loc, arg0, arg1, type);
10755
10756     case BUILT_IN_STRCAT:
10757       return fold_builtin_strcat (loc, arg0, arg1);
10758
10759     case BUILT_IN_STRSPN:
10760       return fold_builtin_strspn (loc, arg0, arg1);
10761
10762     case BUILT_IN_STRCSPN:
10763       return fold_builtin_strcspn (loc, arg0, arg1);
10764
10765     case BUILT_IN_STRCHR:
10766     case BUILT_IN_INDEX:
10767       return fold_builtin_strchr (loc, arg0, arg1, type);
10768
10769     case BUILT_IN_STRRCHR:
10770     case BUILT_IN_RINDEX:
10771       return fold_builtin_strrchr (loc, arg0, arg1, type);
10772
10773     case BUILT_IN_STRCPY:
10774       return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10775
10776     case BUILT_IN_STPCPY:
10777       if (ignore)
10778         {
10779           tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
10780           if (!fn)
10781             break;
10782
10783           return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10784         }
10785       else
10786         return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10787       break;
10788
10789     case BUILT_IN_STRCMP:
10790       return fold_builtin_strcmp (loc, arg0, arg1);
10791
10792     case BUILT_IN_STRPBRK:
10793       return fold_builtin_strpbrk (loc, arg0, arg1, type);
10794
10795     case BUILT_IN_EXPECT:
10796       return fold_builtin_expect (loc, arg0, arg1);
10797
10798     CASE_FLT_FN (BUILT_IN_POW):
10799       return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10800
10801     CASE_FLT_FN (BUILT_IN_POWI):
10802       return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10803
10804     CASE_FLT_FN (BUILT_IN_COPYSIGN):
10805       return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10806
10807     CASE_FLT_FN (BUILT_IN_FMIN):
10808       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10809
10810     CASE_FLT_FN (BUILT_IN_FMAX):
10811       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10812
10813     case BUILT_IN_ISGREATER:
10814       return fold_builtin_unordered_cmp (loc, fndecl,
10815                                          arg0, arg1, UNLE_EXPR, LE_EXPR);
10816     case BUILT_IN_ISGREATEREQUAL:
10817       return fold_builtin_unordered_cmp (loc, fndecl,
10818                                          arg0, arg1, UNLT_EXPR, LT_EXPR);
10819     case BUILT_IN_ISLESS:
10820       return fold_builtin_unordered_cmp (loc, fndecl,
10821                                          arg0, arg1, UNGE_EXPR, GE_EXPR);
10822     case BUILT_IN_ISLESSEQUAL:
10823       return fold_builtin_unordered_cmp (loc, fndecl,
10824                                          arg0, arg1, UNGT_EXPR, GT_EXPR);
10825     case BUILT_IN_ISLESSGREATER:
10826       return fold_builtin_unordered_cmp (loc, fndecl,
10827                                          arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10828     case BUILT_IN_ISUNORDERED:
10829       return fold_builtin_unordered_cmp (loc, fndecl,
10830                                          arg0, arg1, UNORDERED_EXPR,
10831                                          NOP_EXPR);
10832
10833       /* We do the folding for va_start in the expander.  */
10834     case BUILT_IN_VA_START:
10835       break;
10836
10837     case BUILT_IN_SPRINTF:
10838       return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10839
10840     case BUILT_IN_OBJECT_SIZE:
10841       return fold_builtin_object_size (arg0, arg1);
10842
10843     case BUILT_IN_PRINTF:
10844     case BUILT_IN_PRINTF_UNLOCKED:
10845     case BUILT_IN_VPRINTF:
10846       return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10847
10848     case BUILT_IN_PRINTF_CHK:
10849     case BUILT_IN_VPRINTF_CHK:
10850       if (!validate_arg (arg0, INTEGER_TYPE)
10851           || TREE_SIDE_EFFECTS (arg0))
10852         return NULL_TREE;
10853       else
10854         return fold_builtin_printf (loc, fndecl,
10855                                     arg1, NULL_TREE, ignore, fcode);
10856     break;
10857
10858     case BUILT_IN_FPRINTF:
10859     case BUILT_IN_FPRINTF_UNLOCKED:
10860     case BUILT_IN_VFPRINTF:
10861       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10862                                    ignore, fcode);
10863
10864     case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
10865       return fold_builtin_atomic_always_lock_free (arg0, arg1);
10866
10867     case BUILT_IN_ATOMIC_IS_LOCK_FREE:
10868       return fold_builtin_atomic_is_lock_free (arg0, arg1);
10869
10870     default:
10871       break;
10872     }
10873   return NULL_TREE;
10874 }
10875
10876 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10877    and ARG2.  IGNORE is true if the result of the function call is ignored.
10878    This function returns NULL_TREE if no simplification was possible.  */
10879
10880 static tree
10881 fold_builtin_3 (location_t loc, tree fndecl,
10882                 tree arg0, tree arg1, tree arg2, bool ignore)
10883 {
10884   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10885   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10886   switch (fcode)
10887     {
10888
10889     CASE_FLT_FN (BUILT_IN_SINCOS):
10890       return fold_builtin_sincos (loc, arg0, arg1, arg2);
10891
10892     CASE_FLT_FN (BUILT_IN_FMA):
10893       return fold_builtin_fma (loc, arg0, arg1, arg2, type);
10894     break;
10895
10896     CASE_FLT_FN (BUILT_IN_REMQUO):
10897       if (validate_arg (arg0, REAL_TYPE)
10898           && validate_arg(arg1, REAL_TYPE)
10899           && validate_arg(arg2, POINTER_TYPE))
10900         return do_mpfr_remquo (arg0, arg1, arg2);
10901     break;
10902
10903     case BUILT_IN_MEMSET:
10904       return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10905
10906     case BUILT_IN_BCOPY:
10907       return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10908                                      void_type_node, true, /*endp=*/3);
10909
10910     case BUILT_IN_MEMCPY:
10911       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10912                                      type, ignore, /*endp=*/0);
10913
10914     case BUILT_IN_MEMPCPY:
10915       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10916                                      type, ignore, /*endp=*/1);
10917
10918     case BUILT_IN_MEMMOVE:
10919       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10920                                      type, ignore, /*endp=*/3);
10921
10922     case BUILT_IN_STRNCAT:
10923       return fold_builtin_strncat (loc, arg0, arg1, arg2);
10924
10925     case BUILT_IN_STRNCPY:
10926       return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10927
10928     case BUILT_IN_STRNCMP:
10929       return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10930
10931     case BUILT_IN_MEMCHR:
10932       return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10933
10934     case BUILT_IN_BCMP:
10935     case BUILT_IN_MEMCMP:
10936       return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10937
10938     case BUILT_IN_SPRINTF:
10939       return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10940
10941     case BUILT_IN_SNPRINTF:
10942       return fold_builtin_snprintf (loc, arg0, arg1, arg2, NULL_TREE, ignore);
10943
10944     case BUILT_IN_STRCPY_CHK:
10945     case BUILT_IN_STPCPY_CHK:
10946       return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10947                                       ignore, fcode);
10948
10949     case BUILT_IN_STRCAT_CHK:
10950       return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10951
10952     case BUILT_IN_PRINTF_CHK:
10953     case BUILT_IN_VPRINTF_CHK:
10954       if (!validate_arg (arg0, INTEGER_TYPE)
10955           || TREE_SIDE_EFFECTS (arg0))
10956         return NULL_TREE;
10957       else
10958         return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10959     break;
10960
10961     case BUILT_IN_FPRINTF:
10962     case BUILT_IN_FPRINTF_UNLOCKED:
10963     case BUILT_IN_VFPRINTF:
10964       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10965                                    ignore, fcode);
10966
10967     case BUILT_IN_FPRINTF_CHK:
10968     case BUILT_IN_VFPRINTF_CHK:
10969       if (!validate_arg (arg1, INTEGER_TYPE)
10970           || TREE_SIDE_EFFECTS (arg1))
10971         return NULL_TREE;
10972       else
10973         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10974                                      ignore, fcode);
10975
10976     default:
10977       break;
10978     }
10979   return NULL_TREE;
10980 }
10981
10982 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10983    ARG2, and ARG3.  IGNORE is true if the result of the function call is
10984    ignored.  This function returns NULL_TREE if no simplification was
10985    possible.  */
10986
10987 static tree
10988 fold_builtin_4 (location_t loc, tree fndecl,
10989                 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10990 {
10991   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10992
10993   switch (fcode)
10994     {
10995     case BUILT_IN_MEMCPY_CHK:
10996     case BUILT_IN_MEMPCPY_CHK:
10997     case BUILT_IN_MEMMOVE_CHK:
10998     case BUILT_IN_MEMSET_CHK:
10999       return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
11000                                       NULL_TREE, ignore,
11001                                       DECL_FUNCTION_CODE (fndecl));
11002
11003     case BUILT_IN_STRNCPY_CHK:
11004     case BUILT_IN_STPNCPY_CHK:
11005       return fold_builtin_stxncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE,
11006                                        ignore, fcode);
11007
11008     case BUILT_IN_STRNCAT_CHK:
11009       return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
11010
11011     case BUILT_IN_SNPRINTF:
11012       return fold_builtin_snprintf (loc, arg0, arg1, arg2, arg3, ignore);
11013
11014     case BUILT_IN_FPRINTF_CHK:
11015     case BUILT_IN_VFPRINTF_CHK:
11016       if (!validate_arg (arg1, INTEGER_TYPE)
11017           || TREE_SIDE_EFFECTS (arg1))
11018         return NULL_TREE;
11019       else
11020         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
11021                                      ignore, fcode);
11022     break;
11023
11024     default:
11025       break;
11026     }
11027   return NULL_TREE;
11028 }
11029
11030 /* Fold a call to built-in function FNDECL.  ARGS is an array of NARGS
11031     arguments, where NARGS <= 4.  IGNORE is true if the result of the
11032     function call is ignored.  This function returns NULL_TREE if no
11033     simplification was possible.  Note that this only folds builtins with
11034     fixed argument patterns.  Foldings that do varargs-to-varargs
11035     transformations, or that match calls with more than 4 arguments,
11036     need to be handled with fold_builtin_varargs instead.  */
11037
11038 #define MAX_ARGS_TO_FOLD_BUILTIN 4
11039
11040 static tree
11041 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
11042 {
11043   tree ret = NULL_TREE;
11044
11045   switch (nargs)
11046     {
11047     case 0:
11048       ret = fold_builtin_0 (loc, fndecl, ignore);
11049       break;
11050     case 1:
11051       ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
11052       break;
11053     case 2:
11054       ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
11055       break;
11056     case 3:
11057       ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
11058       break;
11059     case 4:
11060       ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
11061                             ignore);
11062       break;
11063     default:
11064       break;
11065     }
11066   if (ret)
11067     {
11068       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
11069       SET_EXPR_LOCATION (ret, loc);
11070       TREE_NO_WARNING (ret) = 1;
11071       return ret;
11072     }
11073   return NULL_TREE;
11074 }
11075
11076 /* Builtins with folding operations that operate on "..." arguments
11077    need special handling; we need to store the arguments in a convenient
11078    data structure before attempting any folding.  Fortunately there are
11079    only a few builtins that fall into this category.  FNDECL is the
11080    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
11081    result of the function call is ignored.  */
11082
11083 static tree
11084 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
11085                       bool ignore ATTRIBUTE_UNUSED)
11086 {
11087   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
11088   tree ret = NULL_TREE;
11089
11090   switch (fcode)
11091     {
11092     case BUILT_IN_SPRINTF_CHK:
11093     case BUILT_IN_VSPRINTF_CHK:
11094       ret = fold_builtin_sprintf_chk (loc, exp, fcode);
11095       break;
11096
11097     case BUILT_IN_SNPRINTF_CHK:
11098     case BUILT_IN_VSNPRINTF_CHK:
11099       ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
11100       break;
11101
11102     case BUILT_IN_FPCLASSIFY:
11103       ret = fold_builtin_fpclassify (loc, exp);
11104       break;
11105
11106     default:
11107       break;
11108     }
11109   if (ret)
11110     {
11111       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
11112       SET_EXPR_LOCATION (ret, loc);
11113       TREE_NO_WARNING (ret) = 1;
11114       return ret;
11115     }
11116   return NULL_TREE;
11117 }
11118
11119 /* Return true if FNDECL shouldn't be folded right now.
11120    If a built-in function has an inline attribute always_inline
11121    wrapper, defer folding it after always_inline functions have
11122    been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
11123    might not be performed.  */
11124
11125 bool
11126 avoid_folding_inline_builtin (tree fndecl)
11127 {
11128   return (DECL_DECLARED_INLINE_P (fndecl)
11129           && DECL_DISREGARD_INLINE_LIMITS (fndecl)
11130           && cfun
11131           && !cfun->always_inline_functions_inlined
11132           && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
11133 }
11134
11135 /* A wrapper function for builtin folding that prevents warnings for
11136    "statement without effect" and the like, caused by removing the
11137    call node earlier than the warning is generated.  */
11138
11139 tree
11140 fold_call_expr (location_t loc, tree exp, bool ignore)
11141 {
11142   tree ret = NULL_TREE;
11143   tree fndecl = get_callee_fndecl (exp);
11144   if (fndecl
11145       && TREE_CODE (fndecl) == FUNCTION_DECL
11146       && DECL_BUILT_IN (fndecl)
11147       /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
11148          yet.  Defer folding until we see all the arguments
11149          (after inlining).  */
11150       && !CALL_EXPR_VA_ARG_PACK (exp))
11151     {
11152       int nargs = call_expr_nargs (exp);
11153
11154       /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
11155          instead last argument is __builtin_va_arg_pack ().  Defer folding
11156          even in that case, until arguments are finalized.  */
11157       if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
11158         {
11159           tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
11160           if (fndecl2
11161               && TREE_CODE (fndecl2) == FUNCTION_DECL
11162               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
11163               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
11164             return NULL_TREE;
11165         }
11166
11167       if (avoid_folding_inline_builtin (fndecl))
11168         return NULL_TREE;
11169
11170       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
11171         return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
11172                                      CALL_EXPR_ARGP (exp), ignore);
11173       else
11174         {
11175           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
11176             {
11177               tree *args = CALL_EXPR_ARGP (exp);
11178               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
11179             }
11180           if (!ret)
11181             ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
11182           if (ret)
11183             return ret;
11184         }
11185     }
11186   return NULL_TREE;
11187 }
11188
11189 /* Conveniently construct a function call expression.  FNDECL names the
11190    function to be called and N arguments are passed in the array
11191    ARGARRAY.  */
11192
11193 tree
11194 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
11195 {
11196   tree fntype = TREE_TYPE (fndecl);
11197   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
11198
11199   return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
11200 }
11201
11202 /* Conveniently construct a function call expression.  FNDECL names the
11203    function to be called and the arguments are passed in the vector
11204    VEC.  */
11205
11206 tree
11207 build_call_expr_loc_vec (location_t loc, tree fndecl, VEC(tree,gc) *vec)
11208 {
11209   return build_call_expr_loc_array (loc, fndecl, VEC_length (tree, vec),
11210                                     VEC_address (tree, vec));
11211 }
11212
11213
11214 /* Conveniently construct a function call expression.  FNDECL names the
11215    function to be called, N is the number of arguments, and the "..."
11216    parameters are the argument expressions.  */
11217
11218 tree
11219 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
11220 {
11221   va_list ap;
11222   tree *argarray = XALLOCAVEC (tree, n);
11223   int i;
11224
11225   va_start (ap, n);
11226   for (i = 0; i < n; i++)
11227     argarray[i] = va_arg (ap, tree);
11228   va_end (ap);
11229   return build_call_expr_loc_array (loc, fndecl, n, argarray);
11230 }
11231
11232 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...).  Duplicated because
11233    varargs macros aren't supported by all bootstrap compilers.  */
11234
11235 tree
11236 build_call_expr (tree fndecl, int n, ...)
11237 {
11238   va_list ap;
11239   tree *argarray = XALLOCAVEC (tree, n);
11240   int i;
11241
11242   va_start (ap, n);
11243   for (i = 0; i < n; i++)
11244     argarray[i] = va_arg (ap, tree);
11245   va_end (ap);
11246   return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
11247 }
11248
11249 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
11250    N arguments are passed in the array ARGARRAY.  */
11251
11252 tree
11253 fold_builtin_call_array (location_t loc, tree type,
11254                          tree fn,
11255                          int n,
11256                          tree *argarray)
11257 {
11258   tree ret = NULL_TREE;
11259    tree exp;
11260
11261   if (TREE_CODE (fn) == ADDR_EXPR)
11262   {
11263     tree fndecl = TREE_OPERAND (fn, 0);
11264     if (TREE_CODE (fndecl) == FUNCTION_DECL
11265         && DECL_BUILT_IN (fndecl))
11266       {
11267         /* If last argument is __builtin_va_arg_pack (), arguments to this
11268            function are not finalized yet.  Defer folding until they are.  */
11269         if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
11270           {
11271             tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
11272             if (fndecl2
11273                 && TREE_CODE (fndecl2) == FUNCTION_DECL
11274                 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
11275                 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
11276               return build_call_array_loc (loc, type, fn, n, argarray);
11277           }
11278         if (avoid_folding_inline_builtin (fndecl))
11279           return build_call_array_loc (loc, type, fn, n, argarray);
11280         if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
11281           {
11282             ret = targetm.fold_builtin (fndecl, n, argarray, false);
11283             if (ret)
11284               return ret;
11285
11286             return build_call_array_loc (loc, type, fn, n, argarray);
11287           }
11288         else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
11289           {
11290             /* First try the transformations that don't require consing up
11291                an exp.  */
11292             ret = fold_builtin_n (loc, fndecl, argarray, n, false);
11293             if (ret)
11294               return ret;
11295           }
11296
11297         /* If we got this far, we need to build an exp.  */
11298         exp = build_call_array_loc (loc, type, fn, n, argarray);
11299         ret = fold_builtin_varargs (loc, fndecl, exp, false);
11300         return ret ? ret : exp;
11301       }
11302   }
11303
11304   return build_call_array_loc (loc, type, fn, n, argarray);
11305 }
11306
11307 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
11308    list ARGS along with N new arguments in NEWARGS.  SKIP is the number
11309    of arguments in ARGS to be omitted.  OLDNARGS is the number of
11310    elements in ARGS.  */
11311
11312 static tree
11313 rewrite_call_expr_valist (location_t loc, int oldnargs, tree *args,
11314                           int skip, tree fndecl, int n, va_list newargs)
11315 {
11316   int nargs = oldnargs - skip + n;
11317   tree *buffer;
11318
11319   if (n > 0)
11320     {
11321       int i, j;
11322
11323       buffer = XALLOCAVEC (tree, nargs);
11324       for (i = 0; i < n; i++)
11325         buffer[i] = va_arg (newargs, tree);
11326       for (j = skip; j < oldnargs; j++, i++)
11327         buffer[i] = args[j];
11328     }
11329   else
11330     buffer = args + skip;
11331
11332   return build_call_expr_loc_array (loc, fndecl, nargs, buffer);
11333 }
11334
11335 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
11336    list ARGS along with N new arguments specified as the "..."
11337    parameters.  SKIP is the number of arguments in ARGS to be omitted.
11338    OLDNARGS is the number of elements in ARGS.  */
11339
11340 static tree
11341 rewrite_call_expr_array (location_t loc, int oldnargs, tree *args,
11342                          int skip, tree fndecl, int n, ...)
11343 {
11344   va_list ap;
11345   tree t;
11346
11347   va_start (ap, n);
11348   t = rewrite_call_expr_valist (loc, oldnargs, args, skip, fndecl, n, ap);
11349   va_end (ap);
11350
11351   return t;
11352 }
11353
11354 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
11355    along with N new arguments specified as the "..." parameters.  SKIP
11356    is the number of arguments in EXP to be omitted.  This function is used
11357    to do varargs-to-varargs transformations.  */
11358
11359 static tree
11360 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
11361 {
11362   va_list ap;
11363   tree t;
11364
11365   va_start (ap, n);
11366   t = rewrite_call_expr_valist (loc, call_expr_nargs (exp),
11367                                 CALL_EXPR_ARGP (exp), skip, fndecl, n, ap);
11368   va_end (ap);
11369
11370   return t;
11371 }
11372
11373 /* Validate a single argument ARG against a tree code CODE representing
11374    a type.  */
11375
11376 static bool
11377 validate_arg (const_tree arg, enum tree_code code)
11378 {
11379   if (!arg)
11380     return false;
11381   else if (code == POINTER_TYPE)
11382     return POINTER_TYPE_P (TREE_TYPE (arg));
11383   else if (code == INTEGER_TYPE)
11384     return INTEGRAL_TYPE_P (TREE_TYPE (arg));
11385   return code == TREE_CODE (TREE_TYPE (arg));
11386 }
11387
11388 /* This function validates the types of a function call argument list
11389    against a specified list of tree_codes.  If the last specifier is a 0,
11390    that represents an ellipses, otherwise the last specifier must be a
11391    VOID_TYPE.
11392
11393    This is the GIMPLE version of validate_arglist.  Eventually we want to
11394    completely convert builtins.c to work from GIMPLEs and the tree based
11395    validate_arglist will then be removed.  */
11396
11397 bool
11398 validate_gimple_arglist (const_gimple call, ...)
11399 {
11400   enum tree_code code;
11401   bool res = 0;
11402   va_list ap;
11403   const_tree arg;
11404   size_t i;
11405
11406   va_start (ap, call);
11407   i = 0;
11408
11409   do
11410     {
11411       code = (enum tree_code) va_arg (ap, int);
11412       switch (code)
11413         {
11414         case 0:
11415           /* This signifies an ellipses, any further arguments are all ok.  */
11416           res = true;
11417           goto end;
11418         case VOID_TYPE:
11419           /* This signifies an endlink, if no arguments remain, return
11420              true, otherwise return false.  */
11421           res = (i == gimple_call_num_args (call));
11422           goto end;
11423         default:
11424           /* If no parameters remain or the parameter's code does not
11425              match the specified code, return false.  Otherwise continue
11426              checking any remaining arguments.  */
11427           arg = gimple_call_arg (call, i++);
11428           if (!validate_arg (arg, code))
11429             goto end;
11430           break;
11431         }
11432     }
11433   while (1);
11434
11435   /* We need gotos here since we can only have one VA_CLOSE in a
11436      function.  */
11437  end: ;
11438   va_end (ap);
11439
11440   return res;
11441 }
11442
11443 /* This function validates the types of a function call argument list
11444    against a specified list of tree_codes.  If the last specifier is a 0,
11445    that represents an ellipses, otherwise the last specifier must be a
11446    VOID_TYPE.  */
11447
11448 bool
11449 validate_arglist (const_tree callexpr, ...)
11450 {
11451   enum tree_code code;
11452   bool res = 0;
11453   va_list ap;
11454   const_call_expr_arg_iterator iter;
11455   const_tree arg;
11456
11457   va_start (ap, callexpr);
11458   init_const_call_expr_arg_iterator (callexpr, &iter);
11459
11460   do
11461     {
11462       code = (enum tree_code) va_arg (ap, int);
11463       switch (code)
11464         {
11465         case 0:
11466           /* This signifies an ellipses, any further arguments are all ok.  */
11467           res = true;
11468           goto end;
11469         case VOID_TYPE:
11470           /* This signifies an endlink, if no arguments remain, return
11471              true, otherwise return false.  */
11472           res = !more_const_call_expr_args_p (&iter);
11473           goto end;
11474         default:
11475           /* If no parameters remain or the parameter's code does not
11476              match the specified code, return false.  Otherwise continue
11477              checking any remaining arguments.  */
11478           arg = next_const_call_expr_arg (&iter);
11479           if (!validate_arg (arg, code))
11480             goto end;
11481           break;
11482         }
11483     }
11484   while (1);
11485
11486   /* We need gotos here since we can only have one VA_CLOSE in a
11487      function.  */
11488  end: ;
11489   va_end (ap);
11490
11491   return res;
11492 }
11493
11494 /* Default target-specific builtin expander that does nothing.  */
11495
11496 rtx
11497 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11498                         rtx target ATTRIBUTE_UNUSED,
11499                         rtx subtarget ATTRIBUTE_UNUSED,
11500                         enum machine_mode mode ATTRIBUTE_UNUSED,
11501                         int ignore ATTRIBUTE_UNUSED)
11502 {
11503   return NULL_RTX;
11504 }
11505
11506 /* Returns true is EXP represents data that would potentially reside
11507    in a readonly section.  */
11508
11509 static bool
11510 readonly_data_expr (tree exp)
11511 {
11512   STRIP_NOPS (exp);
11513
11514   if (TREE_CODE (exp) != ADDR_EXPR)
11515     return false;
11516
11517   exp = get_base_address (TREE_OPERAND (exp, 0));
11518   if (!exp)
11519     return false;
11520
11521   /* Make sure we call decl_readonly_section only for trees it
11522      can handle (since it returns true for everything it doesn't
11523      understand).  */
11524   if (TREE_CODE (exp) == STRING_CST
11525       || TREE_CODE (exp) == CONSTRUCTOR
11526       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11527     return decl_readonly_section (exp, 0);
11528   else
11529     return false;
11530 }
11531
11532 /* Simplify a call to the strstr builtin.  S1 and S2 are the arguments
11533    to the call, and TYPE is its return type.
11534
11535    Return NULL_TREE if no simplification was possible, otherwise return the
11536    simplified form of the call as a tree.
11537
11538    The simplified form may be a constant or other expression which
11539    computes the same value, but in a more efficient manner (including
11540    calls to other builtin functions).
11541
11542    The call may contain arguments which need to be evaluated, but
11543    which are not useful to determine the result of the call.  In
11544    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11545    COMPOUND_EXPR will be an argument which must be evaluated.
11546    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11547    COMPOUND_EXPR in the chain will contain the tree for the simplified
11548    form of the builtin function call.  */
11549
11550 static tree
11551 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11552 {
11553   if (!validate_arg (s1, POINTER_TYPE)
11554       || !validate_arg (s2, POINTER_TYPE))
11555     return NULL_TREE;
11556   else
11557     {
11558       tree fn;
11559       const char *p1, *p2;
11560
11561       p2 = c_getstr (s2);
11562       if (p2 == NULL)
11563         return NULL_TREE;
11564
11565       p1 = c_getstr (s1);
11566       if (p1 != NULL)
11567         {
11568           const char *r = strstr (p1, p2);
11569           tree tem;
11570
11571           if (r == NULL)
11572             return build_int_cst (TREE_TYPE (s1), 0);
11573
11574           /* Return an offset into the constant string argument.  */
11575           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11576           return fold_convert_loc (loc, type, tem);
11577         }
11578
11579       /* The argument is const char *, and the result is char *, so we need
11580          a type conversion here to avoid a warning.  */
11581       if (p2[0] == '\0')
11582         return fold_convert_loc (loc, type, s1);
11583
11584       if (p2[1] != '\0')
11585         return NULL_TREE;
11586
11587       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
11588       if (!fn)
11589         return NULL_TREE;
11590
11591       /* New argument list transforming strstr(s1, s2) to
11592          strchr(s1, s2[0]).  */
11593       return build_call_expr_loc (loc, fn, 2, s1,
11594                                   build_int_cst (integer_type_node, p2[0]));
11595     }
11596 }
11597
11598 /* Simplify a call to the strchr builtin.  S1 and S2 are the arguments to
11599    the call, and TYPE is its return type.
11600
11601    Return NULL_TREE if no simplification was possible, otherwise return the
11602    simplified form of the call as a tree.
11603
11604    The simplified form may be a constant or other expression which
11605    computes the same value, but in a more efficient manner (including
11606    calls to other builtin functions).
11607
11608    The call may contain arguments which need to be evaluated, but
11609    which are not useful to determine the result of the call.  In
11610    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11611    COMPOUND_EXPR will be an argument which must be evaluated.
11612    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11613    COMPOUND_EXPR in the chain will contain the tree for the simplified
11614    form of the builtin function call.  */
11615
11616 static tree
11617 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11618 {
11619   if (!validate_arg (s1, POINTER_TYPE)
11620       || !validate_arg (s2, INTEGER_TYPE))
11621     return NULL_TREE;
11622   else
11623     {
11624       const char *p1;
11625
11626       if (TREE_CODE (s2) != INTEGER_CST)
11627         return NULL_TREE;
11628
11629       p1 = c_getstr (s1);
11630       if (p1 != NULL)
11631         {
11632           char c;
11633           const char *r;
11634           tree tem;
11635
11636           if (target_char_cast (s2, &c))
11637             return NULL_TREE;
11638
11639           r = strchr (p1, c);
11640
11641           if (r == NULL)
11642             return build_int_cst (TREE_TYPE (s1), 0);
11643
11644           /* Return an offset into the constant string argument.  */
11645           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11646           return fold_convert_loc (loc, type, tem);
11647         }
11648       return NULL_TREE;
11649     }
11650 }
11651
11652 /* Simplify a call to the strrchr builtin.  S1 and S2 are the arguments to
11653    the call, and TYPE is its return type.
11654
11655    Return NULL_TREE if no simplification was possible, otherwise return the
11656    simplified form of the call as a tree.
11657
11658    The simplified form may be a constant or other expression which
11659    computes the same value, but in a more efficient manner (including
11660    calls to other builtin functions).
11661
11662    The call may contain arguments which need to be evaluated, but
11663    which are not useful to determine the result of the call.  In
11664    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11665    COMPOUND_EXPR will be an argument which must be evaluated.
11666    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11667    COMPOUND_EXPR in the chain will contain the tree for the simplified
11668    form of the builtin function call.  */
11669
11670 static tree
11671 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11672 {
11673   if (!validate_arg (s1, POINTER_TYPE)
11674       || !validate_arg (s2, INTEGER_TYPE))
11675     return NULL_TREE;
11676   else
11677     {
11678       tree fn;
11679       const char *p1;
11680
11681       if (TREE_CODE (s2) != INTEGER_CST)
11682         return NULL_TREE;
11683
11684       p1 = c_getstr (s1);
11685       if (p1 != NULL)
11686         {
11687           char c;
11688           const char *r;
11689           tree tem;
11690
11691           if (target_char_cast (s2, &c))
11692             return NULL_TREE;
11693
11694           r = strrchr (p1, c);
11695
11696           if (r == NULL)
11697             return build_int_cst (TREE_TYPE (s1), 0);
11698
11699           /* Return an offset into the constant string argument.  */
11700           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11701           return fold_convert_loc (loc, type, tem);
11702         }
11703
11704       if (! integer_zerop (s2))
11705         return NULL_TREE;
11706
11707       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
11708       if (!fn)
11709         return NULL_TREE;
11710
11711       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
11712       return build_call_expr_loc (loc, fn, 2, s1, s2);
11713     }
11714 }
11715
11716 /* Simplify a call to the strpbrk builtin.  S1 and S2 are the arguments
11717    to the call, and TYPE is its return type.
11718
11719    Return NULL_TREE if no simplification was possible, otherwise return the
11720    simplified form of the call as a tree.
11721
11722    The simplified form may be a constant or other expression which
11723    computes the same value, but in a more efficient manner (including
11724    calls to other builtin functions).
11725
11726    The call may contain arguments which need to be evaluated, but
11727    which are not useful to determine the result of the call.  In
11728    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11729    COMPOUND_EXPR will be an argument which must be evaluated.
11730    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11731    COMPOUND_EXPR in the chain will contain the tree for the simplified
11732    form of the builtin function call.  */
11733
11734 static tree
11735 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11736 {
11737   if (!validate_arg (s1, POINTER_TYPE)
11738       || !validate_arg (s2, POINTER_TYPE))
11739     return NULL_TREE;
11740   else
11741     {
11742       tree fn;
11743       const char *p1, *p2;
11744
11745       p2 = c_getstr (s2);
11746       if (p2 == NULL)
11747         return NULL_TREE;
11748
11749       p1 = c_getstr (s1);
11750       if (p1 != NULL)
11751         {
11752           const char *r = strpbrk (p1, p2);
11753           tree tem;
11754
11755           if (r == NULL)
11756             return build_int_cst (TREE_TYPE (s1), 0);
11757
11758           /* Return an offset into the constant string argument.  */
11759           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11760           return fold_convert_loc (loc, type, tem);
11761         }
11762
11763       if (p2[0] == '\0')
11764         /* strpbrk(x, "") == NULL.
11765            Evaluate and ignore s1 in case it had side-effects.  */
11766         return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11767
11768       if (p2[1] != '\0')
11769         return NULL_TREE;  /* Really call strpbrk.  */
11770
11771       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
11772       if (!fn)
11773         return NULL_TREE;
11774
11775       /* New argument list transforming strpbrk(s1, s2) to
11776          strchr(s1, s2[0]).  */
11777       return build_call_expr_loc (loc, fn, 2, s1,
11778                                   build_int_cst (integer_type_node, p2[0]));
11779     }
11780 }
11781
11782 /* Simplify a call to the strcat builtin.  DST and SRC are the arguments
11783    to the call.
11784
11785    Return NULL_TREE if no simplification was possible, otherwise return the
11786    simplified form of the call as a tree.
11787
11788    The simplified form may be a constant or other expression which
11789    computes the same value, but in a more efficient manner (including
11790    calls to other builtin functions).
11791
11792    The call may contain arguments which need to be evaluated, but
11793    which are not useful to determine the result of the call.  In
11794    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11795    COMPOUND_EXPR will be an argument which must be evaluated.
11796    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11797    COMPOUND_EXPR in the chain will contain the tree for the simplified
11798    form of the builtin function call.  */
11799
11800 static tree
11801 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11802 {
11803   if (!validate_arg (dst, POINTER_TYPE)
11804       || !validate_arg (src, POINTER_TYPE))
11805     return NULL_TREE;
11806   else
11807     {
11808       const char *p = c_getstr (src);
11809
11810       /* If the string length is zero, return the dst parameter.  */
11811       if (p && *p == '\0')
11812         return dst;
11813
11814       if (optimize_insn_for_speed_p ())
11815         {
11816           /* See if we can store by pieces into (dst + strlen(dst)).  */
11817           tree newdst, call;
11818           tree strlen_fn = builtin_decl_implicit (BUILT_IN_STRLEN);
11819           tree strcpy_fn = builtin_decl_implicit (BUILT_IN_STRCPY);
11820
11821           if (!strlen_fn || !strcpy_fn)
11822             return NULL_TREE;
11823
11824           /* If we don't have a movstr we don't want to emit an strcpy
11825              call.  We have to do that if the length of the source string
11826              isn't computable (in that case we can use memcpy probably
11827              later expanding to a sequence of mov instructions).  If we
11828              have movstr instructions we can emit strcpy calls.  */
11829           if (!HAVE_movstr)
11830             {
11831               tree len = c_strlen (src, 1);
11832               if (! len || TREE_SIDE_EFFECTS (len))
11833                 return NULL_TREE;
11834             }
11835
11836           /* Stabilize the argument list.  */
11837           dst = builtin_save_expr (dst);
11838
11839           /* Create strlen (dst).  */
11840           newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11841           /* Create (dst p+ strlen (dst)).  */
11842
11843           newdst = fold_build_pointer_plus_loc (loc, dst, newdst);
11844           newdst = builtin_save_expr (newdst);
11845
11846           call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11847           return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11848         }
11849       return NULL_TREE;
11850     }
11851 }
11852
11853 /* Simplify a call to the strncat builtin.  DST, SRC, and LEN are the
11854    arguments to the call.
11855
11856    Return NULL_TREE if no simplification was possible, otherwise return the
11857    simplified form of the call as a tree.
11858
11859    The simplified form may be a constant or other expression which
11860    computes the same value, but in a more efficient manner (including
11861    calls to other builtin functions).
11862
11863    The call may contain arguments which need to be evaluated, but
11864    which are not useful to determine the result of the call.  In
11865    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11866    COMPOUND_EXPR will be an argument which must be evaluated.
11867    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11868    COMPOUND_EXPR in the chain will contain the tree for the simplified
11869    form of the builtin function call.  */
11870
11871 static tree
11872 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11873 {
11874   if (!validate_arg (dst, POINTER_TYPE)
11875       || !validate_arg (src, POINTER_TYPE)
11876       || !validate_arg (len, INTEGER_TYPE))
11877     return NULL_TREE;
11878   else
11879     {
11880       const char *p = c_getstr (src);
11881
11882       /* If the requested length is zero, or the src parameter string
11883          length is zero, return the dst parameter.  */
11884       if (integer_zerop (len) || (p && *p == '\0'))
11885         return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11886
11887       /* If the requested len is greater than or equal to the string
11888          length, call strcat.  */
11889       if (TREE_CODE (len) == INTEGER_CST && p
11890           && compare_tree_int (len, strlen (p)) >= 0)
11891         {
11892           tree fn = builtin_decl_implicit (BUILT_IN_STRCAT);
11893
11894           /* If the replacement _DECL isn't initialized, don't do the
11895              transformation.  */
11896           if (!fn)
11897             return NULL_TREE;
11898
11899           return build_call_expr_loc (loc, fn, 2, dst, src);
11900         }
11901       return NULL_TREE;
11902     }
11903 }
11904
11905 /* Simplify a call to the strspn builtin.  S1 and S2 are the arguments
11906    to the call.
11907
11908    Return NULL_TREE if no simplification was possible, otherwise return the
11909    simplified form of the call as a tree.
11910
11911    The simplified form may be a constant or other expression which
11912    computes the same value, but in a more efficient manner (including
11913    calls to other builtin functions).
11914
11915    The call may contain arguments which need to be evaluated, but
11916    which are not useful to determine the result of the call.  In
11917    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11918    COMPOUND_EXPR will be an argument which must be evaluated.
11919    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11920    COMPOUND_EXPR in the chain will contain the tree for the simplified
11921    form of the builtin function call.  */
11922
11923 static tree
11924 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11925 {
11926   if (!validate_arg (s1, POINTER_TYPE)
11927       || !validate_arg (s2, POINTER_TYPE))
11928     return NULL_TREE;
11929   else
11930     {
11931       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11932
11933       /* If both arguments are constants, evaluate at compile-time.  */
11934       if (p1 && p2)
11935         {
11936           const size_t r = strspn (p1, p2);
11937           return size_int (r);
11938         }
11939
11940       /* If either argument is "", return NULL_TREE.  */
11941       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11942         /* Evaluate and ignore both arguments in case either one has
11943            side-effects.  */
11944         return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11945                                   s1, s2);
11946       return NULL_TREE;
11947     }
11948 }
11949
11950 /* Simplify a call to the strcspn builtin.  S1 and S2 are the arguments
11951    to the call.
11952
11953    Return NULL_TREE if no simplification was possible, otherwise return the
11954    simplified form of the call as a tree.
11955
11956    The simplified form may be a constant or other expression which
11957    computes the same value, but in a more efficient manner (including
11958    calls to other builtin functions).
11959
11960    The call may contain arguments which need to be evaluated, but
11961    which are not useful to determine the result of the call.  In
11962    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11963    COMPOUND_EXPR will be an argument which must be evaluated.
11964    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11965    COMPOUND_EXPR in the chain will contain the tree for the simplified
11966    form of the builtin function call.  */
11967
11968 static tree
11969 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11970 {
11971   if (!validate_arg (s1, POINTER_TYPE)
11972       || !validate_arg (s2, POINTER_TYPE))
11973     return NULL_TREE;
11974   else
11975     {
11976       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11977
11978       /* If both arguments are constants, evaluate at compile-time.  */
11979       if (p1 && p2)
11980         {
11981           const size_t r = strcspn (p1, p2);
11982           return size_int (r);
11983         }
11984
11985       /* If the first argument is "", return NULL_TREE.  */
11986       if (p1 && *p1 == '\0')
11987         {
11988           /* Evaluate and ignore argument s2 in case it has
11989              side-effects.  */
11990           return omit_one_operand_loc (loc, size_type_node,
11991                                    size_zero_node, s2);
11992         }
11993
11994       /* If the second argument is "", return __builtin_strlen(s1).  */
11995       if (p2 && *p2 == '\0')
11996         {
11997           tree fn = builtin_decl_implicit (BUILT_IN_STRLEN);
11998
11999           /* If the replacement _DECL isn't initialized, don't do the
12000              transformation.  */
12001           if (!fn)
12002             return NULL_TREE;
12003
12004           return build_call_expr_loc (loc, fn, 1, s1);
12005         }
12006       return NULL_TREE;
12007     }
12008 }
12009
12010 /* Fold a call to the fputs builtin.  ARG0 and ARG1 are the arguments
12011    to the call.  IGNORE is true if the value returned
12012    by the builtin will be ignored.  UNLOCKED is true is true if this
12013    actually a call to fputs_unlocked.  If LEN in non-NULL, it represents
12014    the known length of the string.  Return NULL_TREE if no simplification
12015    was possible.  */
12016
12017 tree
12018 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
12019                     bool ignore, bool unlocked, tree len)
12020 {
12021   /* If we're using an unlocked function, assume the other unlocked
12022      functions exist explicitly.  */
12023   tree const fn_fputc = (unlocked
12024                          ? builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED)
12025                          : builtin_decl_implicit (BUILT_IN_FPUTC));
12026   tree const fn_fwrite = (unlocked
12027                           ? builtin_decl_explicit (BUILT_IN_FWRITE_UNLOCKED)
12028                           : builtin_decl_implicit (BUILT_IN_FWRITE));
12029
12030   /* If the return value is used, don't do the transformation.  */
12031   if (!ignore)
12032     return NULL_TREE;
12033
12034   /* Verify the arguments in the original call.  */
12035   if (!validate_arg (arg0, POINTER_TYPE)
12036       || !validate_arg (arg1, POINTER_TYPE))
12037     return NULL_TREE;
12038
12039   if (! len)
12040     len = c_strlen (arg0, 0);
12041
12042   /* Get the length of the string passed to fputs.  If the length
12043      can't be determined, punt.  */
12044   if (!len
12045       || TREE_CODE (len) != INTEGER_CST)
12046     return NULL_TREE;
12047
12048   switch (compare_tree_int (len, 1))
12049     {
12050     case -1: /* length is 0, delete the call entirely .  */
12051       return omit_one_operand_loc (loc, integer_type_node,
12052                                integer_zero_node, arg1);;
12053
12054     case 0: /* length is 1, call fputc.  */
12055       {
12056         const char *p = c_getstr (arg0);
12057
12058         if (p != NULL)
12059           {
12060             if (fn_fputc)
12061               return build_call_expr_loc (loc, fn_fputc, 2,
12062                                           build_int_cst
12063                                             (integer_type_node, p[0]), arg1);
12064             else
12065               return NULL_TREE;
12066           }
12067       }
12068       /* FALLTHROUGH */
12069     case 1: /* length is greater than 1, call fwrite.  */
12070       {
12071         /* If optimizing for size keep fputs.  */
12072         if (optimize_function_for_size_p (cfun))
12073           return NULL_TREE;
12074         /* New argument list transforming fputs(string, stream) to
12075            fwrite(string, 1, len, stream).  */
12076         if (fn_fwrite)
12077           return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
12078                                   size_one_node, len, arg1);
12079         else
12080           return NULL_TREE;
12081       }
12082     default:
12083       gcc_unreachable ();
12084     }
12085   return NULL_TREE;
12086 }
12087
12088 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
12089    produced.  False otherwise.  This is done so that we don't output the error
12090    or warning twice or three times.  */
12091
12092 bool
12093 fold_builtin_next_arg (tree exp, bool va_start_p)
12094 {
12095   tree fntype = TREE_TYPE (current_function_decl);
12096   int nargs = call_expr_nargs (exp);
12097   tree arg;
12098
12099   if (!stdarg_p (fntype))
12100     {
12101       error ("%<va_start%> used in function with fixed args");
12102       return true;
12103     }
12104
12105   if (va_start_p)
12106     {
12107       if (va_start_p && (nargs != 2))
12108         {
12109           error ("wrong number of arguments to function %<va_start%>");
12110           return true;
12111         }
12112       arg = CALL_EXPR_ARG (exp, 1);
12113     }
12114   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
12115      when we checked the arguments and if needed issued a warning.  */
12116   else
12117     {
12118       if (nargs == 0)
12119         {
12120           /* Evidently an out of date version of <stdarg.h>; can't validate
12121              va_start's second argument, but can still work as intended.  */
12122           warning (0, "%<__builtin_next_arg%> called without an argument");
12123           return true;
12124         }
12125       else if (nargs > 1)
12126         {
12127           error ("wrong number of arguments to function %<__builtin_next_arg%>");
12128           return true;
12129         }
12130       arg = CALL_EXPR_ARG (exp, 0);
12131     }
12132
12133   if (TREE_CODE (arg) == SSA_NAME)
12134     arg = SSA_NAME_VAR (arg);
12135
12136   /* We destructively modify the call to be __builtin_va_start (ap, 0)
12137      or __builtin_next_arg (0) the first time we see it, after checking
12138      the arguments and if needed issuing a warning.  */
12139   if (!integer_zerop (arg))
12140     {
12141       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
12142
12143       /* Strip off all nops for the sake of the comparison.  This
12144          is not quite the same as STRIP_NOPS.  It does more.
12145          We must also strip off INDIRECT_EXPR for C++ reference
12146          parameters.  */
12147       while (CONVERT_EXPR_P (arg)
12148              || TREE_CODE (arg) == INDIRECT_REF)
12149         arg = TREE_OPERAND (arg, 0);
12150       if (arg != last_parm)
12151         {
12152           /* FIXME: Sometimes with the tree optimizers we can get the
12153              not the last argument even though the user used the last
12154              argument.  We just warn and set the arg to be the last
12155              argument so that we will get wrong-code because of
12156              it.  */
12157           warning (0, "second parameter of %<va_start%> not last named argument");
12158         }
12159
12160       /* Undefined by C99 7.15.1.4p4 (va_start):
12161          "If the parameter parmN is declared with the register storage
12162          class, with a function or array type, or with a type that is
12163          not compatible with the type that results after application of
12164          the default argument promotions, the behavior is undefined."
12165       */
12166       else if (DECL_REGISTER (arg))
12167         warning (0, "undefined behaviour when second parameter of "
12168                  "%<va_start%> is declared with %<register%> storage");
12169
12170       /* We want to verify the second parameter just once before the tree
12171          optimizers are run and then avoid keeping it in the tree,
12172          as otherwise we could warn even for correct code like:
12173          void foo (int i, ...)
12174          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
12175       if (va_start_p)
12176         CALL_EXPR_ARG (exp, 1) = integer_zero_node;
12177       else
12178         CALL_EXPR_ARG (exp, 0) = integer_zero_node;
12179     }
12180   return false;
12181 }
12182
12183
12184 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
12185    ORIG may be null if this is a 2-argument call.  We don't attempt to
12186    simplify calls with more than 3 arguments.
12187
12188    Return NULL_TREE if no simplification was possible, otherwise return the
12189    simplified form of the call as a tree.  If IGNORED is true, it means that
12190    the caller does not use the returned value of the function.  */
12191
12192 static tree
12193 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
12194                       tree orig, int ignored)
12195 {
12196   tree call, retval;
12197   const char *fmt_str = NULL;
12198
12199   /* Verify the required arguments in the original call.  We deal with two
12200      types of sprintf() calls: 'sprintf (str, fmt)' and
12201      'sprintf (dest, "%s", orig)'.  */
12202   if (!validate_arg (dest, POINTER_TYPE)
12203       || !validate_arg (fmt, POINTER_TYPE))
12204     return NULL_TREE;
12205   if (orig && !validate_arg (orig, POINTER_TYPE))
12206     return NULL_TREE;
12207
12208   /* Check whether the format is a literal string constant.  */
12209   fmt_str = c_getstr (fmt);
12210   if (fmt_str == NULL)
12211     return NULL_TREE;
12212
12213   call = NULL_TREE;
12214   retval = NULL_TREE;
12215
12216   if (!init_target_chars ())
12217     return NULL_TREE;
12218
12219   /* If the format doesn't contain % args or %%, use strcpy.  */
12220   if (strchr (fmt_str, target_percent) == NULL)
12221     {
12222       tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12223
12224       if (!fn)
12225         return NULL_TREE;
12226
12227       /* Don't optimize sprintf (buf, "abc", ptr++).  */
12228       if (orig)
12229         return NULL_TREE;
12230
12231       /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
12232          'format' is known to contain no % formats.  */
12233       call = build_call_expr_loc (loc, fn, 2, dest, fmt);
12234       if (!ignored)
12235         retval = build_int_cst (integer_type_node, strlen (fmt_str));
12236     }
12237
12238   /* If the format is "%s", use strcpy if the result isn't used.  */
12239   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
12240     {
12241       tree fn;
12242       fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12243
12244       if (!fn)
12245         return NULL_TREE;
12246
12247       /* Don't crash on sprintf (str1, "%s").  */
12248       if (!orig)
12249         return NULL_TREE;
12250
12251       /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2).  */
12252       if (!ignored)
12253         {
12254           retval = c_strlen (orig, 1);
12255           if (!retval || TREE_CODE (retval) != INTEGER_CST)
12256             return NULL_TREE;
12257         }
12258       call = build_call_expr_loc (loc, fn, 2, dest, orig);
12259     }
12260
12261   if (call && retval)
12262     {
12263       retval = fold_convert_loc
12264         (loc, TREE_TYPE (TREE_TYPE (builtin_decl_implicit (BUILT_IN_SPRINTF))),
12265          retval);
12266       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
12267     }
12268   else
12269     return call;
12270 }
12271
12272 /* Simplify a call to the snprintf builtin with arguments DEST, DESTSIZE,
12273    FMT, and ORIG.  ORIG may be null if this is a 3-argument call.  We don't
12274    attempt to simplify calls with more than 4 arguments.
12275
12276    Return NULL_TREE if no simplification was possible, otherwise return the
12277    simplified form of the call as a tree.  If IGNORED is true, it means that
12278    the caller does not use the returned value of the function.  */
12279
12280 static tree
12281 fold_builtin_snprintf (location_t loc, tree dest, tree destsize, tree fmt,
12282                        tree orig, int ignored)
12283 {
12284   tree call, retval;
12285   const char *fmt_str = NULL;
12286   unsigned HOST_WIDE_INT destlen;
12287
12288   /* Verify the required arguments in the original call.  We deal with two
12289      types of snprintf() calls: 'snprintf (str, cst, fmt)' and
12290      'snprintf (dest, cst, "%s", orig)'.  */
12291   if (!validate_arg (dest, POINTER_TYPE)
12292       || !validate_arg (destsize, INTEGER_TYPE)
12293       || !validate_arg (fmt, POINTER_TYPE))
12294     return NULL_TREE;
12295   if (orig && !validate_arg (orig, POINTER_TYPE))
12296     return NULL_TREE;
12297
12298   if (!host_integerp (destsize, 1))
12299     return NULL_TREE;
12300
12301   /* Check whether the format is a literal string constant.  */
12302   fmt_str = c_getstr (fmt);
12303   if (fmt_str == NULL)
12304     return NULL_TREE;
12305
12306   call = NULL_TREE;
12307   retval = NULL_TREE;
12308
12309   if (!init_target_chars ())
12310     return NULL_TREE;
12311
12312   destlen = tree_low_cst (destsize, 1);
12313
12314   /* If the format doesn't contain % args or %%, use strcpy.  */
12315   if (strchr (fmt_str, target_percent) == NULL)
12316     {
12317       tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12318       size_t len = strlen (fmt_str);
12319
12320       /* Don't optimize snprintf (buf, 4, "abc", ptr++).  */
12321       if (orig)
12322         return NULL_TREE;
12323
12324       /* We could expand this as
12325          memcpy (str, fmt, cst - 1); str[cst - 1] = '\0';
12326          or to
12327          memcpy (str, fmt_with_nul_at_cstm1, cst);
12328          but in the former case that might increase code size
12329          and in the latter case grow .rodata section too much.
12330          So punt for now.  */
12331       if (len >= destlen)
12332         return NULL_TREE;
12333
12334       if (!fn)
12335         return NULL_TREE;
12336
12337       /* Convert snprintf (str, cst, fmt) into strcpy (str, fmt) when
12338          'format' is known to contain no % formats and
12339          strlen (fmt) < cst.  */
12340       call = build_call_expr_loc (loc, fn, 2, dest, fmt);
12341
12342       if (!ignored)
12343         retval = build_int_cst (integer_type_node, strlen (fmt_str));
12344     }
12345
12346   /* If the format is "%s", use strcpy if the result isn't used.  */
12347   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
12348     {
12349       tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12350       unsigned HOST_WIDE_INT origlen;
12351
12352       /* Don't crash on snprintf (str1, cst, "%s").  */
12353       if (!orig)
12354         return NULL_TREE;
12355
12356       retval = c_strlen (orig, 1);
12357       if (!retval || !host_integerp (retval, 1))
12358         return NULL_TREE;
12359
12360       origlen = tree_low_cst (retval, 1);
12361       /* We could expand this as
12362          memcpy (str1, str2, cst - 1); str1[cst - 1] = '\0';
12363          or to
12364          memcpy (str1, str2_with_nul_at_cstm1, cst);
12365          but in the former case that might increase code size
12366          and in the latter case grow .rodata section too much.
12367          So punt for now.  */
12368       if (origlen >= destlen)
12369         return NULL_TREE;
12370
12371       /* Convert snprintf (str1, cst, "%s", str2) into
12372          strcpy (str1, str2) if strlen (str2) < cst.  */
12373       if (!fn)
12374         return NULL_TREE;
12375
12376       call = build_call_expr_loc (loc, fn, 2, dest, orig);
12377
12378       if (ignored)
12379         retval = NULL_TREE;
12380     }
12381
12382   if (call && retval)
12383     {
12384       tree fn = builtin_decl_explicit (BUILT_IN_SNPRINTF);
12385       retval = fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fn)), retval);
12386       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
12387     }
12388   else
12389     return call;
12390 }
12391
12392 /* Expand a call EXP to __builtin_object_size.  */
12393
12394 rtx
12395 expand_builtin_object_size (tree exp)
12396 {
12397   tree ost;
12398   int object_size_type;
12399   tree fndecl = get_callee_fndecl (exp);
12400
12401   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
12402     {
12403       error ("%Kfirst argument of %D must be a pointer, second integer constant",
12404              exp, fndecl);
12405       expand_builtin_trap ();
12406       return const0_rtx;
12407     }
12408
12409   ost = CALL_EXPR_ARG (exp, 1);
12410   STRIP_NOPS (ost);
12411
12412   if (TREE_CODE (ost) != INTEGER_CST
12413       || tree_int_cst_sgn (ost) < 0
12414       || compare_tree_int (ost, 3) > 0)
12415     {
12416       error ("%Klast argument of %D is not integer constant between 0 and 3",
12417              exp, fndecl);
12418       expand_builtin_trap ();
12419       return const0_rtx;
12420     }
12421
12422   object_size_type = tree_low_cst (ost, 0);
12423
12424   return object_size_type < 2 ? constm1_rtx : const0_rtx;
12425 }
12426
12427 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12428    FCODE is the BUILT_IN_* to use.
12429    Return NULL_RTX if we failed; the caller should emit a normal call,
12430    otherwise try to get the result in TARGET, if convenient (and in
12431    mode MODE if that's convenient).  */
12432
12433 static rtx
12434 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
12435                            enum built_in_function fcode)
12436 {
12437   tree dest, src, len, size;
12438
12439   if (!validate_arglist (exp,
12440                          POINTER_TYPE,
12441                          fcode == BUILT_IN_MEMSET_CHK
12442                          ? INTEGER_TYPE : POINTER_TYPE,
12443                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
12444     return NULL_RTX;
12445
12446   dest = CALL_EXPR_ARG (exp, 0);
12447   src = CALL_EXPR_ARG (exp, 1);
12448   len = CALL_EXPR_ARG (exp, 2);
12449   size = CALL_EXPR_ARG (exp, 3);
12450
12451   if (! host_integerp (size, 1))
12452     return NULL_RTX;
12453
12454   if (host_integerp (len, 1) || integer_all_onesp (size))
12455     {
12456       tree fn;
12457
12458       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
12459         {
12460           warning_at (tree_nonartificial_location (exp),
12461                       0, "%Kcall to %D will always overflow destination buffer",
12462                       exp, get_callee_fndecl (exp));
12463           return NULL_RTX;
12464         }
12465
12466       fn = NULL_TREE;
12467       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12468          mem{cpy,pcpy,move,set} is available.  */
12469       switch (fcode)
12470         {
12471         case BUILT_IN_MEMCPY_CHK:
12472           fn = builtin_decl_explicit (BUILT_IN_MEMCPY);
12473           break;
12474         case BUILT_IN_MEMPCPY_CHK:
12475           fn = builtin_decl_explicit (BUILT_IN_MEMPCPY);
12476           break;
12477         case BUILT_IN_MEMMOVE_CHK:
12478           fn = builtin_decl_explicit (BUILT_IN_MEMMOVE);
12479           break;
12480         case BUILT_IN_MEMSET_CHK:
12481           fn = builtin_decl_explicit (BUILT_IN_MEMSET);
12482           break;
12483         default:
12484           break;
12485         }
12486
12487       if (! fn)
12488         return NULL_RTX;
12489
12490       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
12491       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12492       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12493       return expand_expr (fn, target, mode, EXPAND_NORMAL);
12494     }
12495   else if (fcode == BUILT_IN_MEMSET_CHK)
12496     return NULL_RTX;
12497   else
12498     {
12499       unsigned int dest_align = get_pointer_alignment (dest);
12500
12501       /* If DEST is not a pointer type, call the normal function.  */
12502       if (dest_align == 0)
12503         return NULL_RTX;
12504
12505       /* If SRC and DEST are the same (and not volatile), do nothing.  */
12506       if (operand_equal_p (src, dest, 0))
12507         {
12508           tree expr;
12509
12510           if (fcode != BUILT_IN_MEMPCPY_CHK)
12511             {
12512               /* Evaluate and ignore LEN in case it has side-effects.  */
12513               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
12514               return expand_expr (dest, target, mode, EXPAND_NORMAL);
12515             }
12516
12517           expr = fold_build_pointer_plus (dest, len);
12518           return expand_expr (expr, target, mode, EXPAND_NORMAL);
12519         }
12520
12521       /* __memmove_chk special case.  */
12522       if (fcode == BUILT_IN_MEMMOVE_CHK)
12523         {
12524           unsigned int src_align = get_pointer_alignment (src);
12525
12526           if (src_align == 0)
12527             return NULL_RTX;
12528
12529           /* If src is categorized for a readonly section we can use
12530              normal __memcpy_chk.  */
12531           if (readonly_data_expr (src))
12532             {
12533               tree fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
12534               if (!fn)
12535                 return NULL_RTX;
12536               fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
12537                                           dest, src, len, size);
12538               gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12539               CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12540               return expand_expr (fn, target, mode, EXPAND_NORMAL);
12541             }
12542         }
12543       return NULL_RTX;
12544     }
12545 }
12546
12547 /* Emit warning if a buffer overflow is detected at compile time.  */
12548
12549 static void
12550 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
12551 {
12552   int is_strlen = 0;
12553   tree len, size;
12554   location_t loc = tree_nonartificial_location (exp);
12555
12556   switch (fcode)
12557     {
12558     case BUILT_IN_STRCPY_CHK:
12559     case BUILT_IN_STPCPY_CHK:
12560     /* For __strcat_chk the warning will be emitted only if overflowing
12561        by at least strlen (dest) + 1 bytes.  */
12562     case BUILT_IN_STRCAT_CHK:
12563       len = CALL_EXPR_ARG (exp, 1);
12564       size = CALL_EXPR_ARG (exp, 2);
12565       is_strlen = 1;
12566       break;
12567     case BUILT_IN_STRNCAT_CHK:
12568     case BUILT_IN_STRNCPY_CHK:
12569     case BUILT_IN_STPNCPY_CHK:
12570       len = CALL_EXPR_ARG (exp, 2);
12571       size = CALL_EXPR_ARG (exp, 3);
12572       break;
12573     case BUILT_IN_SNPRINTF_CHK:
12574     case BUILT_IN_VSNPRINTF_CHK:
12575       len = CALL_EXPR_ARG (exp, 1);
12576       size = CALL_EXPR_ARG (exp, 3);
12577       break;
12578     default:
12579       gcc_unreachable ();
12580     }
12581
12582   if (!len || !size)
12583     return;
12584
12585   if (! host_integerp (size, 1) || integer_all_onesp (size))
12586     return;
12587
12588   if (is_strlen)
12589     {
12590       len = c_strlen (len, 1);
12591       if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12592         return;
12593     }
12594   else if (fcode == BUILT_IN_STRNCAT_CHK)
12595     {
12596       tree src = CALL_EXPR_ARG (exp, 1);
12597       if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12598         return;
12599       src = c_strlen (src, 1);
12600       if (! src || ! host_integerp (src, 1))
12601         {
12602           warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12603                       exp, get_callee_fndecl (exp));
12604           return;
12605         }
12606       else if (tree_int_cst_lt (src, size))
12607         return;
12608     }
12609   else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12610     return;
12611
12612   warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12613               exp, get_callee_fndecl (exp));
12614 }
12615
12616 /* Emit warning if a buffer overflow is detected at compile time
12617    in __sprintf_chk/__vsprintf_chk calls.  */
12618
12619 static void
12620 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12621 {
12622   tree size, len, fmt;
12623   const char *fmt_str;
12624   int nargs = call_expr_nargs (exp);
12625
12626   /* Verify the required arguments in the original call.  */
12627
12628   if (nargs < 4)
12629     return;
12630   size = CALL_EXPR_ARG (exp, 2);
12631   fmt = CALL_EXPR_ARG (exp, 3);
12632
12633   if (! host_integerp (size, 1) || integer_all_onesp (size))
12634     return;
12635
12636   /* Check whether the format is a literal string constant.  */
12637   fmt_str = c_getstr (fmt);
12638   if (fmt_str == NULL)
12639     return;
12640
12641   if (!init_target_chars ())
12642     return;
12643
12644   /* If the format doesn't contain % args or %%, we know its size.  */
12645   if (strchr (fmt_str, target_percent) == 0)
12646     len = build_int_cstu (size_type_node, strlen (fmt_str));
12647   /* If the format is "%s" and first ... argument is a string literal,
12648      we know it too.  */
12649   else if (fcode == BUILT_IN_SPRINTF_CHK
12650            && strcmp (fmt_str, target_percent_s) == 0)
12651     {
12652       tree arg;
12653
12654       if (nargs < 5)
12655         return;
12656       arg = CALL_EXPR_ARG (exp, 4);
12657       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12658         return;
12659
12660       len = c_strlen (arg, 1);
12661       if (!len || ! host_integerp (len, 1))
12662         return;
12663     }
12664   else
12665     return;
12666
12667   if (! tree_int_cst_lt (len, size))
12668     warning_at (tree_nonartificial_location (exp),
12669                 0, "%Kcall to %D will always overflow destination buffer",
12670                 exp, get_callee_fndecl (exp));
12671 }
12672
12673 /* Emit warning if a free is called with address of a variable.  */
12674
12675 static void
12676 maybe_emit_free_warning (tree exp)
12677 {
12678   tree arg = CALL_EXPR_ARG (exp, 0);
12679
12680   STRIP_NOPS (arg);
12681   if (TREE_CODE (arg) != ADDR_EXPR)
12682     return;
12683
12684   arg = get_base_address (TREE_OPERAND (arg, 0));
12685   if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
12686     return;
12687
12688   if (SSA_VAR_P (arg))
12689     warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
12690                 "%Kattempt to free a non-heap object %qD", exp, arg);
12691   else
12692     warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
12693                 "%Kattempt to free a non-heap object", exp);
12694 }
12695
12696 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12697    if possible.  */
12698
12699 tree
12700 fold_builtin_object_size (tree ptr, tree ost)
12701 {
12702   unsigned HOST_WIDE_INT bytes;
12703   int object_size_type;
12704
12705   if (!validate_arg (ptr, POINTER_TYPE)
12706       || !validate_arg (ost, INTEGER_TYPE))
12707     return NULL_TREE;
12708
12709   STRIP_NOPS (ost);
12710
12711   if (TREE_CODE (ost) != INTEGER_CST
12712       || tree_int_cst_sgn (ost) < 0
12713       || compare_tree_int (ost, 3) > 0)
12714     return NULL_TREE;
12715
12716   object_size_type = tree_low_cst (ost, 0);
12717
12718   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12719      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12720      and (size_t) 0 for types 2 and 3.  */
12721   if (TREE_SIDE_EFFECTS (ptr))
12722     return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12723
12724   if (TREE_CODE (ptr) == ADDR_EXPR)
12725     {
12726       bytes = compute_builtin_object_size (ptr, object_size_type);
12727       if (double_int_fits_to_tree_p (size_type_node,
12728                                      uhwi_to_double_int (bytes)))
12729         return build_int_cstu (size_type_node, bytes);
12730     }
12731   else if (TREE_CODE (ptr) == SSA_NAME)
12732     {
12733       /* If object size is not known yet, delay folding until
12734        later.  Maybe subsequent passes will help determining
12735        it.  */
12736       bytes = compute_builtin_object_size (ptr, object_size_type);
12737       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
12738           && double_int_fits_to_tree_p (size_type_node,
12739                                         uhwi_to_double_int (bytes)))
12740         return build_int_cstu (size_type_node, bytes);
12741     }
12742
12743   return NULL_TREE;
12744 }
12745
12746 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12747    DEST, SRC, LEN, and SIZE are the arguments to the call.
12748    IGNORE is true, if return value can be ignored.  FCODE is the BUILT_IN_*
12749    code of the builtin.  If MAXLEN is not NULL, it is maximum length
12750    passed as third argument.  */
12751
12752 tree
12753 fold_builtin_memory_chk (location_t loc, tree fndecl,
12754                          tree dest, tree src, tree len, tree size,
12755                          tree maxlen, bool ignore,
12756                          enum built_in_function fcode)
12757 {
12758   tree fn;
12759
12760   if (!validate_arg (dest, POINTER_TYPE)
12761       || !validate_arg (src,
12762                         (fcode == BUILT_IN_MEMSET_CHK
12763                          ? INTEGER_TYPE : POINTER_TYPE))
12764       || !validate_arg (len, INTEGER_TYPE)
12765       || !validate_arg (size, INTEGER_TYPE))
12766     return NULL_TREE;
12767
12768   /* If SRC and DEST are the same (and not volatile), return DEST
12769      (resp. DEST+LEN for __mempcpy_chk).  */
12770   if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12771     {
12772       if (fcode != BUILT_IN_MEMPCPY_CHK)
12773         return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12774                                  dest, len);
12775       else
12776         {
12777           tree temp = fold_build_pointer_plus_loc (loc, dest, len);
12778           return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12779         }
12780     }
12781
12782   if (! host_integerp (size, 1))
12783     return NULL_TREE;
12784
12785   if (! integer_all_onesp (size))
12786     {
12787       if (! host_integerp (len, 1))
12788         {
12789           /* If LEN is not constant, try MAXLEN too.
12790              For MAXLEN only allow optimizing into non-_ocs function
12791              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12792           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12793             {
12794               if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12795                 {
12796                   /* (void) __mempcpy_chk () can be optimized into
12797                      (void) __memcpy_chk ().  */
12798                   fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
12799                   if (!fn)
12800                     return NULL_TREE;
12801
12802                   return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12803                 }
12804               return NULL_TREE;
12805             }
12806         }
12807       else
12808         maxlen = len;
12809
12810       if (tree_int_cst_lt (size, maxlen))
12811         return NULL_TREE;
12812     }
12813
12814   fn = NULL_TREE;
12815   /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12816      mem{cpy,pcpy,move,set} is available.  */
12817   switch (fcode)
12818     {
12819     case BUILT_IN_MEMCPY_CHK:
12820       fn = builtin_decl_explicit (BUILT_IN_MEMCPY);
12821       break;
12822     case BUILT_IN_MEMPCPY_CHK:
12823       fn = builtin_decl_explicit (BUILT_IN_MEMPCPY);
12824       break;
12825     case BUILT_IN_MEMMOVE_CHK:
12826       fn = builtin_decl_explicit (BUILT_IN_MEMMOVE);
12827       break;
12828     case BUILT_IN_MEMSET_CHK:
12829       fn = builtin_decl_explicit (BUILT_IN_MEMSET);
12830       break;
12831     default:
12832       break;
12833     }
12834
12835   if (!fn)
12836     return NULL_TREE;
12837
12838   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12839 }
12840
12841 /* Fold a call to the __st[rp]cpy_chk builtin.
12842    DEST, SRC, and SIZE are the arguments to the call.
12843    IGNORE is true if return value can be ignored.  FCODE is the BUILT_IN_*
12844    code of the builtin.  If MAXLEN is not NULL, it is maximum length of
12845    strings passed as second argument.  */
12846
12847 tree
12848 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12849                          tree src, tree size,
12850                          tree maxlen, bool ignore,
12851                          enum built_in_function fcode)
12852 {
12853   tree len, fn;
12854
12855   if (!validate_arg (dest, POINTER_TYPE)
12856       || !validate_arg (src, POINTER_TYPE)
12857       || !validate_arg (size, INTEGER_TYPE))
12858     return NULL_TREE;
12859
12860   /* If SRC and DEST are the same (and not volatile), return DEST.  */
12861   if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12862     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12863
12864   if (! host_integerp (size, 1))
12865     return NULL_TREE;
12866
12867   if (! integer_all_onesp (size))
12868     {
12869       len = c_strlen (src, 1);
12870       if (! len || ! host_integerp (len, 1))
12871         {
12872           /* If LEN is not constant, try MAXLEN too.
12873              For MAXLEN only allow optimizing into non-_ocs function
12874              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12875           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12876             {
12877               if (fcode == BUILT_IN_STPCPY_CHK)
12878                 {
12879                   if (! ignore)
12880                     return NULL_TREE;
12881
12882                   /* If return value of __stpcpy_chk is ignored,
12883                      optimize into __strcpy_chk.  */
12884                   fn = builtin_decl_explicit (BUILT_IN_STRCPY_CHK);
12885                   if (!fn)
12886                     return NULL_TREE;
12887
12888                   return build_call_expr_loc (loc, fn, 3, dest, src, size);
12889                 }
12890
12891               if (! len || TREE_SIDE_EFFECTS (len))
12892                 return NULL_TREE;
12893
12894               /* If c_strlen returned something, but not a constant,
12895                  transform __strcpy_chk into __memcpy_chk.  */
12896               fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
12897               if (!fn)
12898                 return NULL_TREE;
12899
12900               len = fold_convert_loc (loc, size_type_node, len);
12901               len = size_binop_loc (loc, PLUS_EXPR, len,
12902                                     build_int_cst (size_type_node, 1));
12903               return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12904                                        build_call_expr_loc (loc, fn, 4,
12905                                                         dest, src, len, size));
12906             }
12907         }
12908       else
12909         maxlen = len;
12910
12911       if (! tree_int_cst_lt (maxlen, size))
12912         return NULL_TREE;
12913     }
12914
12915   /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available.  */
12916   fn = builtin_decl_explicit (fcode == BUILT_IN_STPCPY_CHK
12917                               ? BUILT_IN_STPCPY : BUILT_IN_STRCPY);
12918   if (!fn)
12919     return NULL_TREE;
12920
12921   return build_call_expr_loc (loc, fn, 2, dest, src);
12922 }
12923
12924 /* Fold a call to the __st{r,p}ncpy_chk builtin.  DEST, SRC, LEN, and SIZE
12925    are the arguments to the call.  If MAXLEN is not NULL, it is maximum
12926    length passed as third argument. IGNORE is true if return value can be
12927    ignored. FCODE is the BUILT_IN_* code of the builtin. */
12928
12929 tree
12930 fold_builtin_stxncpy_chk (location_t loc, tree dest, tree src,
12931                           tree len, tree size, tree maxlen, bool ignore,
12932                           enum built_in_function fcode)
12933 {
12934   tree fn;
12935
12936   if (!validate_arg (dest, POINTER_TYPE)
12937       || !validate_arg (src, POINTER_TYPE)
12938       || !validate_arg (len, INTEGER_TYPE)
12939       || !validate_arg (size, INTEGER_TYPE))
12940     return NULL_TREE;
12941
12942   if (fcode == BUILT_IN_STPNCPY_CHK && ignore)
12943     {
12944        /* If return value of __stpncpy_chk is ignored,
12945           optimize into __strncpy_chk.  */
12946        fn = builtin_decl_explicit (BUILT_IN_STRNCPY_CHK);
12947        if (fn)
12948          return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12949     }
12950
12951   if (! host_integerp (size, 1))
12952     return NULL_TREE;
12953
12954   if (! integer_all_onesp (size))
12955     {
12956       if (! host_integerp (len, 1))
12957         {
12958           /* If LEN is not constant, try MAXLEN too.
12959              For MAXLEN only allow optimizing into non-_ocs function
12960              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12961           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12962             return NULL_TREE;
12963         }
12964       else
12965         maxlen = len;
12966
12967       if (tree_int_cst_lt (size, maxlen))
12968         return NULL_TREE;
12969     }
12970
12971   /* If __builtin_st{r,p}ncpy_chk is used, assume st{r,p}ncpy is available.  */
12972   fn = builtin_decl_explicit (fcode == BUILT_IN_STPNCPY_CHK
12973                               ? BUILT_IN_STPNCPY : BUILT_IN_STRNCPY);
12974   if (!fn)
12975     return NULL_TREE;
12976
12977   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12978 }
12979
12980 /* Fold a call to the __strcat_chk builtin FNDECL.  DEST, SRC, and SIZE
12981    are the arguments to the call.  */
12982
12983 static tree
12984 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12985                          tree src, tree size)
12986 {
12987   tree fn;
12988   const char *p;
12989
12990   if (!validate_arg (dest, POINTER_TYPE)
12991       || !validate_arg (src, POINTER_TYPE)
12992       || !validate_arg (size, INTEGER_TYPE))
12993     return NULL_TREE;
12994
12995   p = c_getstr (src);
12996   /* If the SRC parameter is "", return DEST.  */
12997   if (p && *p == '\0')
12998     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12999
13000   if (! host_integerp (size, 1) || ! integer_all_onesp (size))
13001     return NULL_TREE;
13002
13003   /* If __builtin_strcat_chk is used, assume strcat is available.  */
13004   fn = builtin_decl_explicit (BUILT_IN_STRCAT);
13005   if (!fn)
13006     return NULL_TREE;
13007
13008   return build_call_expr_loc (loc, fn, 2, dest, src);
13009 }
13010
13011 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
13012    LEN, and SIZE.  */
13013
13014 static tree
13015 fold_builtin_strncat_chk (location_t loc, tree fndecl,
13016                           tree dest, tree src, tree len, tree size)
13017 {
13018   tree fn;
13019   const char *p;
13020
13021   if (!validate_arg (dest, POINTER_TYPE)
13022       || !validate_arg (src, POINTER_TYPE)
13023       || !validate_arg (size, INTEGER_TYPE)
13024       || !validate_arg (size, INTEGER_TYPE))
13025     return NULL_TREE;
13026
13027   p = c_getstr (src);
13028   /* If the SRC parameter is "" or if LEN is 0, return DEST.  */
13029   if (p && *p == '\0')
13030     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
13031   else if (integer_zerop (len))
13032     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
13033
13034   if (! host_integerp (size, 1))
13035     return NULL_TREE;
13036
13037   if (! integer_all_onesp (size))
13038     {
13039       tree src_len = c_strlen (src, 1);
13040       if (src_len
13041           && host_integerp (src_len, 1)
13042           && host_integerp (len, 1)
13043           && ! tree_int_cst_lt (len, src_len))
13044         {
13045           /* If LEN >= strlen (SRC), optimize into __strcat_chk.  */
13046           fn = builtin_decl_explicit (BUILT_IN_STRCAT_CHK);
13047           if (!fn)
13048             return NULL_TREE;
13049
13050           return build_call_expr_loc (loc, fn, 3, dest, src, size);
13051         }
13052       return NULL_TREE;
13053     }
13054
13055   /* If __builtin_strncat_chk is used, assume strncat is available.  */
13056   fn = builtin_decl_explicit (BUILT_IN_STRNCAT);
13057   if (!fn)
13058     return NULL_TREE;
13059
13060   return build_call_expr_loc (loc, fn, 3, dest, src, len);
13061 }
13062
13063 /* Fold a call EXP to __{,v}sprintf_chk having NARGS passed as ARGS.
13064    Return NULL_TREE if a normal call should be emitted rather than
13065    expanding the function inline.  FCODE is either BUILT_IN_SPRINTF_CHK
13066    or BUILT_IN_VSPRINTF_CHK.  */
13067
13068 static tree
13069 fold_builtin_sprintf_chk_1 (location_t loc, int nargs, tree *args,
13070                             enum built_in_function fcode)
13071 {
13072   tree dest, size, len, fn, fmt, flag;
13073   const char *fmt_str;
13074
13075   /* Verify the required arguments in the original call.  */
13076   if (nargs < 4)
13077     return NULL_TREE;
13078   dest = args[0];
13079   if (!validate_arg (dest, POINTER_TYPE))
13080     return NULL_TREE;
13081   flag = args[1];
13082   if (!validate_arg (flag, INTEGER_TYPE))
13083     return NULL_TREE;
13084   size = args[2];
13085   if (!validate_arg (size, INTEGER_TYPE))
13086     return NULL_TREE;
13087   fmt = args[3];
13088   if (!validate_arg (fmt, POINTER_TYPE))
13089     return NULL_TREE;
13090
13091   if (! host_integerp (size, 1))
13092     return NULL_TREE;
13093
13094   len = NULL_TREE;
13095
13096   if (!init_target_chars ())
13097     return NULL_TREE;
13098
13099   /* Check whether the format is a literal string constant.  */
13100   fmt_str = c_getstr (fmt);
13101   if (fmt_str != NULL)
13102     {
13103       /* If the format doesn't contain % args or %%, we know the size.  */
13104       if (strchr (fmt_str, target_percent) == 0)
13105         {
13106           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
13107             len = build_int_cstu (size_type_node, strlen (fmt_str));
13108         }
13109       /* If the format is "%s" and first ... argument is a string literal,
13110          we know the size too.  */
13111       else if (fcode == BUILT_IN_SPRINTF_CHK
13112                && strcmp (fmt_str, target_percent_s) == 0)
13113         {
13114           tree arg;
13115
13116           if (nargs == 5)
13117             {
13118               arg = args[4];
13119               if (validate_arg (arg, POINTER_TYPE))
13120                 {
13121                   len = c_strlen (arg, 1);
13122                   if (! len || ! host_integerp (len, 1))
13123                     len = NULL_TREE;
13124                 }
13125             }
13126         }
13127     }
13128
13129   if (! integer_all_onesp (size))
13130     {
13131       if (! len || ! tree_int_cst_lt (len, size))
13132         return NULL_TREE;
13133     }
13134
13135   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13136      or if format doesn't contain % chars or is "%s".  */
13137   if (! integer_zerop (flag))
13138     {
13139       if (fmt_str == NULL)
13140         return NULL_TREE;
13141       if (strchr (fmt_str, target_percent) != NULL
13142           && strcmp (fmt_str, target_percent_s))
13143         return NULL_TREE;
13144     }
13145
13146   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
13147   fn = builtin_decl_explicit (fcode == BUILT_IN_VSPRINTF_CHK
13148                               ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF);
13149   if (!fn)
13150     return NULL_TREE;
13151
13152   return rewrite_call_expr_array (loc, nargs, args, 4, fn, 2, dest, fmt);
13153 }
13154
13155 /* Fold a call EXP to __{,v}sprintf_chk.  Return NULL_TREE if
13156    a normal call should be emitted rather than expanding the function
13157    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
13158
13159 static tree
13160 fold_builtin_sprintf_chk (location_t loc, tree exp,
13161                           enum built_in_function fcode)
13162 {
13163   return fold_builtin_sprintf_chk_1 (loc, call_expr_nargs (exp),
13164                                      CALL_EXPR_ARGP (exp), fcode);
13165 }
13166
13167 /* Fold a call EXP to {,v}snprintf having NARGS passed as ARGS.  Return
13168    NULL_TREE if a normal call should be emitted rather than expanding
13169    the function inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
13170    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
13171    passed as second argument.  */
13172
13173 static tree
13174 fold_builtin_snprintf_chk_1 (location_t loc, int nargs, tree *args,
13175                              tree maxlen, enum built_in_function fcode)
13176 {
13177   tree dest, size, len, fn, fmt, flag;
13178   const char *fmt_str;
13179
13180   /* Verify the required arguments in the original call.  */
13181   if (nargs < 5)
13182     return NULL_TREE;
13183   dest = args[0];
13184   if (!validate_arg (dest, POINTER_TYPE))
13185     return NULL_TREE;
13186   len = args[1];
13187   if (!validate_arg (len, INTEGER_TYPE))
13188     return NULL_TREE;
13189   flag = args[2];
13190   if (!validate_arg (flag, INTEGER_TYPE))
13191     return NULL_TREE;
13192   size = args[3];
13193   if (!validate_arg (size, INTEGER_TYPE))
13194     return NULL_TREE;
13195   fmt = args[4];
13196   if (!validate_arg (fmt, POINTER_TYPE))
13197     return NULL_TREE;
13198
13199   if (! host_integerp (size, 1))
13200     return NULL_TREE;
13201
13202   if (! integer_all_onesp (size))
13203     {
13204       if (! host_integerp (len, 1))
13205         {
13206           /* If LEN is not constant, try MAXLEN too.
13207              For MAXLEN only allow optimizing into non-_ocs function
13208              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
13209           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
13210             return NULL_TREE;
13211         }
13212       else
13213         maxlen = len;
13214
13215       if (tree_int_cst_lt (size, maxlen))
13216         return NULL_TREE;
13217     }
13218
13219   if (!init_target_chars ())
13220     return NULL_TREE;
13221
13222   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13223      or if format doesn't contain % chars or is "%s".  */
13224   if (! integer_zerop (flag))
13225     {
13226       fmt_str = c_getstr (fmt);
13227       if (fmt_str == NULL)
13228         return NULL_TREE;
13229       if (strchr (fmt_str, target_percent) != NULL
13230           && strcmp (fmt_str, target_percent_s))
13231         return NULL_TREE;
13232     }
13233
13234   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13235      available.  */
13236   fn = builtin_decl_explicit (fcode == BUILT_IN_VSNPRINTF_CHK
13237                               ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF);
13238   if (!fn)
13239     return NULL_TREE;
13240
13241   return rewrite_call_expr_array (loc, nargs, args, 5, fn, 3, dest, len, fmt);
13242 }
13243
13244 /* Fold a call EXP to {,v}snprintf.  Return NULL_TREE if
13245    a normal call should be emitted rather than expanding the function
13246    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
13247    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
13248    passed as second argument.  */
13249
13250 tree
13251 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
13252                            enum built_in_function fcode)
13253 {
13254   return fold_builtin_snprintf_chk_1 (loc, call_expr_nargs (exp),
13255                                       CALL_EXPR_ARGP (exp), maxlen, fcode);
13256 }
13257
13258 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
13259    FMT and ARG are the arguments to the call; we don't fold cases with
13260    more than 2 arguments, and ARG may be null if this is a 1-argument case.
13261
13262    Return NULL_TREE if no simplification was possible, otherwise return the
13263    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
13264    code of the function to be simplified.  */
13265
13266 static tree
13267 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
13268                      tree arg, bool ignore,
13269                      enum built_in_function fcode)
13270 {
13271   tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
13272   const char *fmt_str = NULL;
13273
13274   /* If the return value is used, don't do the transformation.  */
13275   if (! ignore)
13276     return NULL_TREE;
13277
13278   /* Verify the required arguments in the original call.  */
13279   if (!validate_arg (fmt, POINTER_TYPE))
13280     return NULL_TREE;
13281
13282   /* Check whether the format is a literal string constant.  */
13283   fmt_str = c_getstr (fmt);
13284   if (fmt_str == NULL)
13285     return NULL_TREE;
13286
13287   if (fcode == BUILT_IN_PRINTF_UNLOCKED)
13288     {
13289       /* If we're using an unlocked function, assume the other
13290          unlocked functions exist explicitly.  */
13291       fn_putchar = builtin_decl_explicit (BUILT_IN_PUTCHAR_UNLOCKED);
13292       fn_puts = builtin_decl_explicit (BUILT_IN_PUTS_UNLOCKED);
13293     }
13294   else
13295     {
13296       fn_putchar = builtin_decl_implicit (BUILT_IN_PUTCHAR);
13297       fn_puts = builtin_decl_implicit (BUILT_IN_PUTS);
13298     }
13299
13300   if (!init_target_chars ())
13301     return NULL_TREE;
13302
13303   if (strcmp (fmt_str, target_percent_s) == 0
13304       || strchr (fmt_str, target_percent) == NULL)
13305     {
13306       const char *str;
13307
13308       if (strcmp (fmt_str, target_percent_s) == 0)
13309         {
13310           if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
13311             return NULL_TREE;
13312
13313           if (!arg || !validate_arg (arg, POINTER_TYPE))
13314             return NULL_TREE;
13315
13316           str = c_getstr (arg);
13317           if (str == NULL)
13318             return NULL_TREE;
13319         }
13320       else
13321         {
13322           /* The format specifier doesn't contain any '%' characters.  */
13323           if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
13324               && arg)
13325             return NULL_TREE;
13326           str = fmt_str;
13327         }
13328
13329       /* If the string was "", printf does nothing.  */
13330       if (str[0] == '\0')
13331         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
13332
13333       /* If the string has length of 1, call putchar.  */
13334       if (str[1] == '\0')
13335         {
13336           /* Given printf("c"), (where c is any one character,)
13337              convert "c"[0] to an int and pass that to the replacement
13338              function.  */
13339           newarg = build_int_cst (integer_type_node, str[0]);
13340           if (fn_putchar)
13341             call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
13342         }
13343       else
13344         {
13345           /* If the string was "string\n", call puts("string").  */
13346           size_t len = strlen (str);
13347           if ((unsigned char)str[len - 1] == target_newline
13348               && (size_t) (int) len == len
13349               && (int) len > 0)
13350             {
13351               char *newstr;
13352               tree offset_node, string_cst;
13353
13354               /* Create a NUL-terminated string that's one char shorter
13355                  than the original, stripping off the trailing '\n'.  */
13356               newarg = build_string_literal (len, str);
13357               string_cst = string_constant (newarg, &offset_node);
13358               gcc_checking_assert (string_cst
13359                                    && (TREE_STRING_LENGTH (string_cst)
13360                                        == (int) len)
13361                                    && integer_zerop (offset_node)
13362                                    && (unsigned char)
13363                                       TREE_STRING_POINTER (string_cst)[len - 1]
13364                                       == target_newline);
13365               /* build_string_literal creates a new STRING_CST,
13366                  modify it in place to avoid double copying.  */
13367               newstr = CONST_CAST (char *, TREE_STRING_POINTER (string_cst));
13368               newstr[len - 1] = '\0';
13369               if (fn_puts)
13370                 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
13371             }
13372           else
13373             /* We'd like to arrange to call fputs(string,stdout) here,
13374                but we need stdout and don't have a way to get it yet.  */
13375             return NULL_TREE;
13376         }
13377     }
13378
13379   /* The other optimizations can be done only on the non-va_list variants.  */
13380   else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
13381     return NULL_TREE;
13382
13383   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
13384   else if (strcmp (fmt_str, target_percent_s_newline) == 0)
13385     {
13386       if (!arg || !validate_arg (arg, POINTER_TYPE))
13387         return NULL_TREE;
13388       if (fn_puts)
13389         call = build_call_expr_loc (loc, fn_puts, 1, arg);
13390     }
13391
13392   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
13393   else if (strcmp (fmt_str, target_percent_c) == 0)
13394     {
13395       if (!arg || !validate_arg (arg, INTEGER_TYPE))
13396         return NULL_TREE;
13397       if (fn_putchar)
13398         call = build_call_expr_loc (loc, fn_putchar, 1, arg);
13399     }
13400
13401   if (!call)
13402     return NULL_TREE;
13403
13404   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
13405 }
13406
13407 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
13408    FP, FMT, and ARG are the arguments to the call.  We don't fold calls with
13409    more than 3 arguments, and ARG may be null in the 2-argument case.
13410
13411    Return NULL_TREE if no simplification was possible, otherwise return the
13412    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
13413    code of the function to be simplified.  */
13414
13415 static tree
13416 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
13417                       tree fmt, tree arg, bool ignore,
13418                       enum built_in_function fcode)
13419 {
13420   tree fn_fputc, fn_fputs, call = NULL_TREE;
13421   const char *fmt_str = NULL;
13422
13423   /* If the return value is used, don't do the transformation.  */
13424   if (! ignore)
13425     return NULL_TREE;
13426
13427   /* Verify the required arguments in the original call.  */
13428   if (!validate_arg (fp, POINTER_TYPE))
13429     return NULL_TREE;
13430   if (!validate_arg (fmt, POINTER_TYPE))
13431     return NULL_TREE;
13432
13433   /* Check whether the format is a literal string constant.  */
13434   fmt_str = c_getstr (fmt);
13435   if (fmt_str == NULL)
13436     return NULL_TREE;
13437
13438   if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
13439     {
13440       /* If we're using an unlocked function, assume the other
13441          unlocked functions exist explicitly.  */
13442       fn_fputc = builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED);
13443       fn_fputs = builtin_decl_explicit (BUILT_IN_FPUTS_UNLOCKED);
13444     }
13445   else
13446     {
13447       fn_fputc = builtin_decl_implicit (BUILT_IN_FPUTC);
13448       fn_fputs = builtin_decl_implicit (BUILT_IN_FPUTS);
13449     }
13450
13451   if (!init_target_chars ())
13452     return NULL_TREE;
13453
13454   /* If the format doesn't contain % args or %%, use strcpy.  */
13455   if (strchr (fmt_str, target_percent) == NULL)
13456     {
13457       if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
13458           && arg)
13459         return NULL_TREE;
13460
13461       /* If the format specifier was "", fprintf does nothing.  */
13462       if (fmt_str[0] == '\0')
13463         {
13464           /* If FP has side-effects, just wait until gimplification is
13465              done.  */
13466           if (TREE_SIDE_EFFECTS (fp))
13467             return NULL_TREE;
13468
13469           return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
13470         }
13471
13472       /* When "string" doesn't contain %, replace all cases of
13473          fprintf (fp, string) with fputs (string, fp).  The fputs
13474          builtin will take care of special cases like length == 1.  */
13475       if (fn_fputs)
13476         call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
13477     }
13478
13479   /* The other optimizations can be done only on the non-va_list variants.  */
13480   else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
13481     return NULL_TREE;
13482
13483   /* If the format specifier was "%s", call __builtin_fputs (arg, fp).  */
13484   else if (strcmp (fmt_str, target_percent_s) == 0)
13485     {
13486       if (!arg || !validate_arg (arg, POINTER_TYPE))
13487         return NULL_TREE;
13488       if (fn_fputs)
13489         call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
13490     }
13491
13492   /* If the format specifier was "%c", call __builtin_fputc (arg, fp).  */
13493   else if (strcmp (fmt_str, target_percent_c) == 0)
13494     {
13495       if (!arg || !validate_arg (arg, INTEGER_TYPE))
13496         return NULL_TREE;
13497       if (fn_fputc)
13498         call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
13499     }
13500
13501   if (!call)
13502     return NULL_TREE;
13503   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
13504 }
13505
13506 /* Initialize format string characters in the target charset.  */
13507
13508 static bool
13509 init_target_chars (void)
13510 {
13511   static bool init;
13512   if (!init)
13513     {
13514       target_newline = lang_hooks.to_target_charset ('\n');
13515       target_percent = lang_hooks.to_target_charset ('%');
13516       target_c = lang_hooks.to_target_charset ('c');
13517       target_s = lang_hooks.to_target_charset ('s');
13518       if (target_newline == 0 || target_percent == 0 || target_c == 0
13519           || target_s == 0)
13520         return false;
13521
13522       target_percent_c[0] = target_percent;
13523       target_percent_c[1] = target_c;
13524       target_percent_c[2] = '\0';
13525
13526       target_percent_s[0] = target_percent;
13527       target_percent_s[1] = target_s;
13528       target_percent_s[2] = '\0';
13529
13530       target_percent_s_newline[0] = target_percent;
13531       target_percent_s_newline[1] = target_s;
13532       target_percent_s_newline[2] = target_newline;
13533       target_percent_s_newline[3] = '\0';
13534
13535       init = true;
13536     }
13537   return true;
13538 }
13539
13540 /* Helper function for do_mpfr_arg*().  Ensure M is a normal number
13541    and no overflow/underflow occurred.  INEXACT is true if M was not
13542    exactly calculated.  TYPE is the tree type for the result.  This
13543    function assumes that you cleared the MPFR flags and then
13544    calculated M to see if anything subsequently set a flag prior to
13545    entering this function.  Return NULL_TREE if any checks fail.  */
13546
13547 static tree
13548 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
13549 {
13550   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13551      overflow/underflow occurred.  If -frounding-math, proceed iff the
13552      result of calling FUNC was exact.  */
13553   if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
13554       && (!flag_rounding_math || !inexact))
13555     {
13556       REAL_VALUE_TYPE rr;
13557
13558       real_from_mpfr (&rr, m, type, GMP_RNDN);
13559       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
13560          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
13561          but the mpft_t is not, then we underflowed in the
13562          conversion.  */
13563       if (real_isfinite (&rr)
13564           && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
13565         {
13566           REAL_VALUE_TYPE rmode;
13567
13568           real_convert (&rmode, TYPE_MODE (type), &rr);
13569           /* Proceed iff the specified mode can hold the value.  */
13570           if (real_identical (&rmode, &rr))
13571             return build_real (type, rmode);
13572         }
13573     }
13574   return NULL_TREE;
13575 }
13576
13577 /* Helper function for do_mpc_arg*().  Ensure M is a normal complex
13578    number and no overflow/underflow occurred.  INEXACT is true if M
13579    was not exactly calculated.  TYPE is the tree type for the result.
13580    This function assumes that you cleared the MPFR flags and then
13581    calculated M to see if anything subsequently set a flag prior to
13582    entering this function.  Return NULL_TREE if any checks fail, if
13583    FORCE_CONVERT is true, then bypass the checks.  */
13584
13585 static tree
13586 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
13587 {
13588   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13589      overflow/underflow occurred.  If -frounding-math, proceed iff the
13590      result of calling FUNC was exact.  */
13591   if (force_convert
13592       || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
13593           && !mpfr_overflow_p () && !mpfr_underflow_p ()
13594           && (!flag_rounding_math || !inexact)))
13595     {
13596       REAL_VALUE_TYPE re, im;
13597
13598       real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
13599       real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
13600       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
13601          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
13602          but the mpft_t is not, then we underflowed in the
13603          conversion.  */
13604       if (force_convert
13605           || (real_isfinite (&re) && real_isfinite (&im)
13606               && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
13607               && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
13608         {
13609           REAL_VALUE_TYPE re_mode, im_mode;
13610
13611           real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
13612           real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
13613           /* Proceed iff the specified mode can hold the value.  */
13614           if (force_convert
13615               || (real_identical (&re_mode, &re)
13616                   && real_identical (&im_mode, &im)))
13617             return build_complex (type, build_real (TREE_TYPE (type), re_mode),
13618                                   build_real (TREE_TYPE (type), im_mode));
13619         }
13620     }
13621   return NULL_TREE;
13622 }
13623
13624 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
13625    FUNC on it and return the resulting value as a tree with type TYPE.
13626    If MIN and/or MAX are not NULL, then the supplied ARG must be
13627    within those bounds.  If INCLUSIVE is true, then MIN/MAX are
13628    acceptable values, otherwise they are not.  The mpfr precision is
13629    set to the precision of TYPE.  We assume that function FUNC returns
13630    zero if the result could be calculated exactly within the requested
13631    precision.  */
13632
13633 static tree
13634 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
13635               const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
13636               bool inclusive)
13637 {
13638   tree result = NULL_TREE;
13639
13640   STRIP_NOPS (arg);
13641
13642   /* To proceed, MPFR must exactly represent the target floating point
13643      format, which only happens when the target base equals two.  */
13644   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13645       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13646     {
13647       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13648
13649       if (real_isfinite (ra)
13650           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13651           && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13652         {
13653           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13654           const int prec = fmt->p;
13655           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13656           int inexact;
13657           mpfr_t m;
13658
13659           mpfr_init2 (m, prec);
13660           mpfr_from_real (m, ra, GMP_RNDN);
13661           mpfr_clear_flags ();
13662           inexact = func (m, m, rnd);
13663           result = do_mpfr_ckconv (m, type, inexact);
13664           mpfr_clear (m);
13665         }
13666     }
13667
13668   return result;
13669 }
13670
13671 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13672    FUNC on it and return the resulting value as a tree with type TYPE.
13673    The mpfr precision is set to the precision of TYPE.  We assume that
13674    function FUNC returns zero if the result could be calculated
13675    exactly within the requested precision.  */
13676
13677 static tree
13678 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13679               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13680 {
13681   tree result = NULL_TREE;
13682
13683   STRIP_NOPS (arg1);
13684   STRIP_NOPS (arg2);
13685
13686   /* To proceed, MPFR must exactly represent the target floating point
13687      format, which only happens when the target base equals two.  */
13688   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13689       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13690       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13691     {
13692       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13693       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13694
13695       if (real_isfinite (ra1) && real_isfinite (ra2))
13696         {
13697           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13698           const int prec = fmt->p;
13699           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13700           int inexact;
13701           mpfr_t m1, m2;
13702
13703           mpfr_inits2 (prec, m1, m2, NULL);
13704           mpfr_from_real (m1, ra1, GMP_RNDN);
13705           mpfr_from_real (m2, ra2, GMP_RNDN);
13706           mpfr_clear_flags ();
13707           inexact = func (m1, m1, m2, rnd);
13708           result = do_mpfr_ckconv (m1, type, inexact);
13709           mpfr_clears (m1, m2, NULL);
13710         }
13711     }
13712
13713   return result;
13714 }
13715
13716 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13717    FUNC on it and return the resulting value as a tree with type TYPE.
13718    The mpfr precision is set to the precision of TYPE.  We assume that
13719    function FUNC returns zero if the result could be calculated
13720    exactly within the requested precision.  */
13721
13722 static tree
13723 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13724               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13725 {
13726   tree result = NULL_TREE;
13727
13728   STRIP_NOPS (arg1);
13729   STRIP_NOPS (arg2);
13730   STRIP_NOPS (arg3);
13731
13732   /* To proceed, MPFR must exactly represent the target floating point
13733      format, which only happens when the target base equals two.  */
13734   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13735       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13736       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13737       && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13738     {
13739       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13740       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13741       const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13742
13743       if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13744         {
13745           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13746           const int prec = fmt->p;
13747           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13748           int inexact;
13749           mpfr_t m1, m2, m3;
13750
13751           mpfr_inits2 (prec, m1, m2, m3, NULL);
13752           mpfr_from_real (m1, ra1, GMP_RNDN);
13753           mpfr_from_real (m2, ra2, GMP_RNDN);
13754           mpfr_from_real (m3, ra3, GMP_RNDN);
13755           mpfr_clear_flags ();
13756           inexact = func (m1, m1, m2, m3, rnd);
13757           result = do_mpfr_ckconv (m1, type, inexact);
13758           mpfr_clears (m1, m2, m3, NULL);
13759         }
13760     }
13761
13762   return result;
13763 }
13764
13765 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13766    the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13767    If ARG_SINP and ARG_COSP are NULL then the result is returned
13768    as a complex value.
13769    The type is taken from the type of ARG and is used for setting the
13770    precision of the calculation and results.  */
13771
13772 static tree
13773 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13774 {
13775   tree const type = TREE_TYPE (arg);
13776   tree result = NULL_TREE;
13777
13778   STRIP_NOPS (arg);
13779
13780   /* To proceed, MPFR must exactly represent the target floating point
13781      format, which only happens when the target base equals two.  */
13782   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13783       && TREE_CODE (arg) == REAL_CST
13784       && !TREE_OVERFLOW (arg))
13785     {
13786       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13787
13788       if (real_isfinite (ra))
13789         {
13790           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13791           const int prec = fmt->p;
13792           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13793           tree result_s, result_c;
13794           int inexact;
13795           mpfr_t m, ms, mc;
13796
13797           mpfr_inits2 (prec, m, ms, mc, NULL);
13798           mpfr_from_real (m, ra, GMP_RNDN);
13799           mpfr_clear_flags ();
13800           inexact = mpfr_sin_cos (ms, mc, m, rnd);
13801           result_s = do_mpfr_ckconv (ms, type, inexact);
13802           result_c = do_mpfr_ckconv (mc, type, inexact);
13803           mpfr_clears (m, ms, mc, NULL);
13804           if (result_s && result_c)
13805             {
13806               /* If we are to return in a complex value do so.  */
13807               if (!arg_sinp && !arg_cosp)
13808                 return build_complex (build_complex_type (type),
13809                                       result_c, result_s);
13810
13811               /* Dereference the sin/cos pointer arguments.  */
13812               arg_sinp = build_fold_indirect_ref (arg_sinp);
13813               arg_cosp = build_fold_indirect_ref (arg_cosp);
13814               /* Proceed if valid pointer type were passed in.  */
13815               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13816                   && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13817                 {
13818                   /* Set the values. */
13819                   result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13820                                           result_s);
13821                   TREE_SIDE_EFFECTS (result_s) = 1;
13822                   result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13823                                           result_c);
13824                   TREE_SIDE_EFFECTS (result_c) = 1;
13825                   /* Combine the assignments into a compound expr.  */
13826                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13827                                                     result_s, result_c));
13828                 }
13829             }
13830         }
13831     }
13832   return result;
13833 }
13834
13835 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13836    two-argument mpfr order N Bessel function FUNC on them and return
13837    the resulting value as a tree with type TYPE.  The mpfr precision
13838    is set to the precision of TYPE.  We assume that function FUNC
13839    returns zero if the result could be calculated exactly within the
13840    requested precision.  */
13841 static tree
13842 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13843                   int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13844                   const REAL_VALUE_TYPE *min, bool inclusive)
13845 {
13846   tree result = NULL_TREE;
13847
13848   STRIP_NOPS (arg1);
13849   STRIP_NOPS (arg2);
13850
13851   /* To proceed, MPFR must exactly represent the target floating point
13852      format, which only happens when the target base equals two.  */
13853   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13854       && host_integerp (arg1, 0)
13855       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13856     {
13857       const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13858       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13859
13860       if (n == (long)n
13861           && real_isfinite (ra)
13862           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13863         {
13864           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13865           const int prec = fmt->p;
13866           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13867           int inexact;
13868           mpfr_t m;
13869
13870           mpfr_init2 (m, prec);
13871           mpfr_from_real (m, ra, GMP_RNDN);
13872           mpfr_clear_flags ();
13873           inexact = func (m, n, m, rnd);
13874           result = do_mpfr_ckconv (m, type, inexact);
13875           mpfr_clear (m);
13876         }
13877     }
13878
13879   return result;
13880 }
13881
13882 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13883    the pointer *(ARG_QUO) and return the result.  The type is taken
13884    from the type of ARG0 and is used for setting the precision of the
13885    calculation and results.  */
13886
13887 static tree
13888 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13889 {
13890   tree const type = TREE_TYPE (arg0);
13891   tree result = NULL_TREE;
13892
13893   STRIP_NOPS (arg0);
13894   STRIP_NOPS (arg1);
13895
13896   /* To proceed, MPFR must exactly represent the target floating point
13897      format, which only happens when the target base equals two.  */
13898   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13899       && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13900       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13901     {
13902       const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13903       const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13904
13905       if (real_isfinite (ra0) && real_isfinite (ra1))
13906         {
13907           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13908           const int prec = fmt->p;
13909           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13910           tree result_rem;
13911           long integer_quo;
13912           mpfr_t m0, m1;
13913
13914           mpfr_inits2 (prec, m0, m1, NULL);
13915           mpfr_from_real (m0, ra0, GMP_RNDN);
13916           mpfr_from_real (m1, ra1, GMP_RNDN);
13917           mpfr_clear_flags ();
13918           mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13919           /* Remquo is independent of the rounding mode, so pass
13920              inexact=0 to do_mpfr_ckconv().  */
13921           result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13922           mpfr_clears (m0, m1, NULL);
13923           if (result_rem)
13924             {
13925               /* MPFR calculates quo in the host's long so it may
13926                  return more bits in quo than the target int can hold
13927                  if sizeof(host long) > sizeof(target int).  This can
13928                  happen even for native compilers in LP64 mode.  In
13929                  these cases, modulo the quo value with the largest
13930                  number that the target int can hold while leaving one
13931                  bit for the sign.  */
13932               if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13933                 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13934
13935               /* Dereference the quo pointer argument.  */
13936               arg_quo = build_fold_indirect_ref (arg_quo);
13937               /* Proceed iff a valid pointer type was passed in.  */
13938               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13939                 {
13940                   /* Set the value. */
13941                   tree result_quo
13942                     = fold_build2 (MODIFY_EXPR, TREE_TYPE (arg_quo), arg_quo,
13943                                    build_int_cst (TREE_TYPE (arg_quo),
13944                                                   integer_quo));
13945                   TREE_SIDE_EFFECTS (result_quo) = 1;
13946                   /* Combine the quo assignment with the rem.  */
13947                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13948                                                     result_quo, result_rem));
13949                 }
13950             }
13951         }
13952     }
13953   return result;
13954 }
13955
13956 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13957    resulting value as a tree with type TYPE.  The mpfr precision is
13958    set to the precision of TYPE.  We assume that this mpfr function
13959    returns zero if the result could be calculated exactly within the
13960    requested precision.  In addition, the integer pointer represented
13961    by ARG_SG will be dereferenced and set to the appropriate signgam
13962    (-1,1) value.  */
13963
13964 static tree
13965 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13966 {
13967   tree result = NULL_TREE;
13968
13969   STRIP_NOPS (arg);
13970
13971   /* To proceed, MPFR must exactly represent the target floating point
13972      format, which only happens when the target base equals two.  Also
13973      verify ARG is a constant and that ARG_SG is an int pointer.  */
13974   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13975       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13976       && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13977       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13978     {
13979       const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13980
13981       /* In addition to NaN and Inf, the argument cannot be zero or a
13982          negative integer.  */
13983       if (real_isfinite (ra)
13984           && ra->cl != rvc_zero
13985           && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13986         {
13987           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13988           const int prec = fmt->p;
13989           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13990           int inexact, sg;
13991           mpfr_t m;
13992           tree result_lg;
13993
13994           mpfr_init2 (m, prec);
13995           mpfr_from_real (m, ra, GMP_RNDN);
13996           mpfr_clear_flags ();
13997           inexact = mpfr_lgamma (m, &sg, m, rnd);
13998           result_lg = do_mpfr_ckconv (m, type, inexact);
13999           mpfr_clear (m);
14000           if (result_lg)
14001             {
14002               tree result_sg;
14003
14004               /* Dereference the arg_sg pointer argument.  */
14005               arg_sg = build_fold_indirect_ref (arg_sg);
14006               /* Assign the signgam value into *arg_sg. */
14007               result_sg = fold_build2 (MODIFY_EXPR,
14008                                        TREE_TYPE (arg_sg), arg_sg,
14009                                        build_int_cst (TREE_TYPE (arg_sg), sg));
14010               TREE_SIDE_EFFECTS (result_sg) = 1;
14011               /* Combine the signgam assignment with the lgamma result.  */
14012               result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
14013                                                 result_sg, result_lg));
14014             }
14015         }
14016     }
14017
14018   return result;
14019 }
14020
14021 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
14022    function FUNC on it and return the resulting value as a tree with
14023    type TYPE.  The mpfr precision is set to the precision of TYPE.  We
14024    assume that function FUNC returns zero if the result could be
14025    calculated exactly within the requested precision.  */
14026
14027 static tree
14028 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
14029 {
14030   tree result = NULL_TREE;
14031
14032   STRIP_NOPS (arg);
14033
14034   /* To proceed, MPFR must exactly represent the target floating point
14035      format, which only happens when the target base equals two.  */
14036   if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
14037       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
14038       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
14039     {
14040       const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
14041       const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
14042
14043       if (real_isfinite (re) && real_isfinite (im))
14044         {
14045           const struct real_format *const fmt =
14046             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
14047           const int prec = fmt->p;
14048           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
14049           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
14050           int inexact;
14051           mpc_t m;
14052
14053           mpc_init2 (m, prec);
14054           mpfr_from_real (mpc_realref(m), re, rnd);
14055           mpfr_from_real (mpc_imagref(m), im, rnd);
14056           mpfr_clear_flags ();
14057           inexact = func (m, m, crnd);
14058           result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
14059           mpc_clear (m);
14060         }
14061     }
14062
14063   return result;
14064 }
14065
14066 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
14067    mpc function FUNC on it and return the resulting value as a tree
14068    with type TYPE.  The mpfr precision is set to the precision of
14069    TYPE.  We assume that function FUNC returns zero if the result
14070    could be calculated exactly within the requested precision.  If
14071    DO_NONFINITE is true, then fold expressions containing Inf or NaN
14072    in the arguments and/or results.  */
14073
14074 tree
14075 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
14076              int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
14077 {
14078   tree result = NULL_TREE;
14079
14080   STRIP_NOPS (arg0);
14081   STRIP_NOPS (arg1);
14082
14083   /* To proceed, MPFR must exactly represent the target floating point
14084      format, which only happens when the target base equals two.  */
14085   if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
14086       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
14087       && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
14088       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
14089       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
14090     {
14091       const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
14092       const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
14093       const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
14094       const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
14095
14096       if (do_nonfinite
14097           || (real_isfinite (re0) && real_isfinite (im0)
14098               && real_isfinite (re1) && real_isfinite (im1)))
14099         {
14100           const struct real_format *const fmt =
14101             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
14102           const int prec = fmt->p;
14103           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
14104           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
14105           int inexact;
14106           mpc_t m0, m1;
14107
14108           mpc_init2 (m0, prec);
14109           mpc_init2 (m1, prec);
14110           mpfr_from_real (mpc_realref(m0), re0, rnd);
14111           mpfr_from_real (mpc_imagref(m0), im0, rnd);
14112           mpfr_from_real (mpc_realref(m1), re1, rnd);
14113           mpfr_from_real (mpc_imagref(m1), im1, rnd);
14114           mpfr_clear_flags ();
14115           inexact = func (m0, m0, m1, crnd);
14116           result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
14117           mpc_clear (m0);
14118           mpc_clear (m1);
14119         }
14120     }
14121
14122   return result;
14123 }
14124
14125 /* Fold a call STMT to __{,v}sprintf_chk.  Return NULL_TREE if
14126    a normal call should be emitted rather than expanding the function
14127    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
14128
14129 static tree
14130 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
14131 {
14132   int nargs = gimple_call_num_args (stmt);
14133
14134   return fold_builtin_sprintf_chk_1 (gimple_location (stmt), nargs,
14135                                      (nargs > 0
14136                                       ? gimple_call_arg_ptr (stmt, 0)
14137                                       : &error_mark_node), fcode);
14138 }
14139
14140 /* Fold a call STMT to {,v}snprintf.  Return NULL_TREE if
14141    a normal call should be emitted rather than expanding the function
14142    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
14143    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
14144    passed as second argument.  */
14145
14146 tree
14147 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
14148                                   enum built_in_function fcode)
14149 {
14150   int nargs = gimple_call_num_args (stmt);
14151
14152   return fold_builtin_snprintf_chk_1 (gimple_location (stmt), nargs,
14153                                       (nargs > 0
14154                                        ? gimple_call_arg_ptr (stmt, 0)
14155                                        : &error_mark_node), maxlen, fcode);
14156 }
14157
14158 /* Builtins with folding operations that operate on "..." arguments
14159    need special handling; we need to store the arguments in a convenient
14160    data structure before attempting any folding.  Fortunately there are
14161    only a few builtins that fall into this category.  FNDECL is the
14162    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
14163    result of the function call is ignored.  */
14164
14165 static tree
14166 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
14167                              bool ignore ATTRIBUTE_UNUSED)
14168 {
14169   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
14170   tree ret = NULL_TREE;
14171
14172   switch (fcode)
14173     {
14174     case BUILT_IN_SPRINTF_CHK:
14175     case BUILT_IN_VSPRINTF_CHK:
14176       ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
14177       break;
14178
14179     case BUILT_IN_SNPRINTF_CHK:
14180     case BUILT_IN_VSNPRINTF_CHK:
14181       ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
14182
14183     default:
14184       break;
14185     }
14186   if (ret)
14187     {
14188       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
14189       TREE_NO_WARNING (ret) = 1;
14190       return ret;
14191     }
14192   return NULL_TREE;
14193 }
14194
14195 /* A wrapper function for builtin folding that prevents warnings for
14196    "statement without effect" and the like, caused by removing the
14197    call node earlier than the warning is generated.  */
14198
14199 tree
14200 fold_call_stmt (gimple stmt, bool ignore)
14201 {
14202   tree ret = NULL_TREE;
14203   tree fndecl = gimple_call_fndecl (stmt);
14204   location_t loc = gimple_location (stmt);
14205   if (fndecl
14206       && TREE_CODE (fndecl) == FUNCTION_DECL
14207       && DECL_BUILT_IN (fndecl)
14208       && !gimple_call_va_arg_pack_p (stmt))
14209     {
14210       int nargs = gimple_call_num_args (stmt);
14211       tree *args = (nargs > 0
14212                     ? gimple_call_arg_ptr (stmt, 0)
14213                     : &error_mark_node);
14214
14215       if (avoid_folding_inline_builtin (fndecl))
14216         return NULL_TREE;
14217       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
14218         {
14219           return targetm.fold_builtin (fndecl, nargs, args, ignore);
14220         }
14221       else
14222         {
14223           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
14224             ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
14225           if (!ret)
14226             ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
14227           if (ret)
14228             {
14229               /* Propagate location information from original call to
14230                  expansion of builtin.  Otherwise things like
14231                  maybe_emit_chk_warning, that operate on the expansion
14232                  of a builtin, will use the wrong location information.  */
14233               if (gimple_has_location (stmt))
14234                 {
14235                   tree realret = ret;
14236                   if (TREE_CODE (ret) == NOP_EXPR)
14237                     realret = TREE_OPERAND (ret, 0);
14238                   if (CAN_HAVE_LOCATION_P (realret)
14239                       && !EXPR_HAS_LOCATION (realret))
14240                     SET_EXPR_LOCATION (realret, loc);
14241                   return realret;
14242                 }
14243               return ret;
14244             }
14245         }
14246     }
14247   return NULL_TREE;
14248 }
14249
14250 /* Look up the function in builtin_decl that corresponds to DECL
14251    and set ASMSPEC as its user assembler name.  DECL must be a
14252    function decl that declares a builtin.  */
14253
14254 void
14255 set_builtin_user_assembler_name (tree decl, const char *asmspec)
14256 {
14257   tree builtin;
14258   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
14259               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
14260               && asmspec != 0);
14261
14262   builtin = builtin_decl_explicit (DECL_FUNCTION_CODE (decl));
14263   set_user_assembler_name (builtin, asmspec);
14264   switch (DECL_FUNCTION_CODE (decl))
14265     {
14266     case BUILT_IN_MEMCPY:
14267       init_block_move_fn (asmspec);
14268       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
14269       break;
14270     case BUILT_IN_MEMSET:
14271       init_block_clear_fn (asmspec);
14272       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
14273       break;
14274     case BUILT_IN_MEMMOVE:
14275       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
14276       break;
14277     case BUILT_IN_MEMCMP:
14278       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
14279       break;
14280     case BUILT_IN_ABORT:
14281       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
14282       break;
14283     case BUILT_IN_FFS:
14284       if (INT_TYPE_SIZE < BITS_PER_WORD)
14285         {
14286           set_user_assembler_libfunc ("ffs", asmspec);
14287           set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
14288                                                        MODE_INT, 0), "ffs");
14289         }
14290       break;
14291     default:
14292       break;
14293     }
14294 }
14295
14296 /* Return true if DECL is a builtin that expands to a constant or similarly
14297    simple code.  */
14298 bool
14299 is_simple_builtin (tree decl)
14300 {
14301   if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
14302     switch (DECL_FUNCTION_CODE (decl))
14303       {
14304         /* Builtins that expand to constants.  */
14305       case BUILT_IN_CONSTANT_P:
14306       case BUILT_IN_EXPECT:
14307       case BUILT_IN_OBJECT_SIZE:
14308       case BUILT_IN_UNREACHABLE:
14309         /* Simple register moves or loads from stack.  */
14310       case BUILT_IN_ASSUME_ALIGNED:
14311       case BUILT_IN_RETURN_ADDRESS:
14312       case BUILT_IN_EXTRACT_RETURN_ADDR:
14313       case BUILT_IN_FROB_RETURN_ADDR:
14314       case BUILT_IN_RETURN:
14315       case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
14316       case BUILT_IN_FRAME_ADDRESS:
14317       case BUILT_IN_VA_END:
14318       case BUILT_IN_STACK_SAVE:
14319       case BUILT_IN_STACK_RESTORE:
14320         /* Exception state returns or moves registers around.  */
14321       case BUILT_IN_EH_FILTER:
14322       case BUILT_IN_EH_POINTER:
14323       case BUILT_IN_EH_COPY_VALUES:
14324         return true;
14325
14326       default:
14327         return false;
14328       }
14329
14330   return false;
14331 }
14332
14333 /* Return true if DECL is a builtin that is not expensive, i.e., they are
14334    most probably expanded inline into reasonably simple code.  This is a
14335    superset of is_simple_builtin.  */
14336 bool
14337 is_inexpensive_builtin (tree decl)
14338 {
14339   if (!decl)
14340     return false;
14341   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
14342     return true;
14343   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
14344     switch (DECL_FUNCTION_CODE (decl))
14345       {
14346       case BUILT_IN_ABS:
14347       case BUILT_IN_ALLOCA:
14348       case BUILT_IN_ALLOCA_WITH_ALIGN:
14349       case BUILT_IN_BSWAP16:
14350       case BUILT_IN_BSWAP32:
14351       case BUILT_IN_BSWAP64:
14352       case BUILT_IN_CLZ:
14353       case BUILT_IN_CLZIMAX:
14354       case BUILT_IN_CLZL:
14355       case BUILT_IN_CLZLL:
14356       case BUILT_IN_CTZ:
14357       case BUILT_IN_CTZIMAX:
14358       case BUILT_IN_CTZL:
14359       case BUILT_IN_CTZLL:
14360       case BUILT_IN_FFS:
14361       case BUILT_IN_FFSIMAX:
14362       case BUILT_IN_FFSL:
14363       case BUILT_IN_FFSLL:
14364       case BUILT_IN_IMAXABS:
14365       case BUILT_IN_FINITE:
14366       case BUILT_IN_FINITEF:
14367       case BUILT_IN_FINITEL:
14368       case BUILT_IN_FINITED32:
14369       case BUILT_IN_FINITED64:
14370       case BUILT_IN_FINITED128:
14371       case BUILT_IN_FPCLASSIFY:
14372       case BUILT_IN_ISFINITE:
14373       case BUILT_IN_ISINF_SIGN:
14374       case BUILT_IN_ISINF:
14375       case BUILT_IN_ISINFF:
14376       case BUILT_IN_ISINFL:
14377       case BUILT_IN_ISINFD32:
14378       case BUILT_IN_ISINFD64:
14379       case BUILT_IN_ISINFD128:
14380       case BUILT_IN_ISNAN:
14381       case BUILT_IN_ISNANF:
14382       case BUILT_IN_ISNANL:
14383       case BUILT_IN_ISNAND32:
14384       case BUILT_IN_ISNAND64:
14385       case BUILT_IN_ISNAND128:
14386       case BUILT_IN_ISNORMAL:
14387       case BUILT_IN_ISGREATER:
14388       case BUILT_IN_ISGREATEREQUAL:
14389       case BUILT_IN_ISLESS:
14390       case BUILT_IN_ISLESSEQUAL:
14391       case BUILT_IN_ISLESSGREATER:
14392       case BUILT_IN_ISUNORDERED:
14393       case BUILT_IN_VA_ARG_PACK:
14394       case BUILT_IN_VA_ARG_PACK_LEN:
14395       case BUILT_IN_VA_COPY:
14396       case BUILT_IN_TRAP:
14397       case BUILT_IN_SAVEREGS:
14398       case BUILT_IN_POPCOUNTL:
14399       case BUILT_IN_POPCOUNTLL:
14400       case BUILT_IN_POPCOUNTIMAX:
14401       case BUILT_IN_POPCOUNT:
14402       case BUILT_IN_PARITYL:
14403       case BUILT_IN_PARITYLL:
14404       case BUILT_IN_PARITYIMAX:
14405       case BUILT_IN_PARITY:
14406       case BUILT_IN_LABS:
14407       case BUILT_IN_LLABS:
14408       case BUILT_IN_PREFETCH:
14409         return true;
14410
14411       default:
14412         return is_simple_builtin (decl);
14413       }
14414
14415   return false;
14416 }