gcc/builtins.c

   1 /* Expand builtin functions.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "machmode.h"
  27 #include "rtl.h"
  28 #include "tree.h"
  29 #include "realmpfr.h"
  30 #include "gimple.h"
  31 #include "flags.h"
  32 #include "regs.h"
  33 #include "hard-reg-set.h"
  34 #include "except.h"
  35 #include "function.h"
  36 #include "insn-config.h"
  37 #include "expr.h"
  38 #include "optabs.h"
  39 #include "libfuncs.h"
  40 #include "recog.h"
  41 #include "output.h"
  42 #include "typeclass.h"
  43 #include "toplev.h"
  44 #include "predict.h"
  45 #include "tm_p.h"
  46 #include "target.h"
  47 #include "langhooks.h"
  48 #include "basic-block.h"
  49 #include "tree-mudflap.h"
  50 #include "tree-flow.h"
  51 #include "value-prof.h"
  52 #include "diagnostic-core.h"
  53 #include "builtins.h"
  54
  55 #ifndef SLOW_UNALIGNED_ACCESS
  56 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
  57 #endif
  58
  59 #ifndef PAD_VARARGS_DOWN
  60 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
  61 #endif
  62 static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));
  63
  64 struct target_builtins default_target_builtins;
  65 #if SWITCHABLE_TARGET
  66 struct target_builtins *this_target_builtins = &default_target_builtins;
  67 #endif
  68
  69 /* Define the names of the builtin function types and codes.  */
  70 const char *const built_in_class_names[4]
  71   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
  72
  73 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
  74 const char * built_in_names[(int) END_BUILTINS] =
  75 {
  76 #include "builtins.def"
  77 };
  78 #undef DEF_BUILTIN
  79
  80 /* Setup an array of _DECL trees, make sure each element is
  81    initialized to NULL_TREE.  */
  82 tree built_in_decls[(int) END_BUILTINS];
  83 /* Declarations used when constructing the builtin implicitly in the compiler.
  84    It may be NULL_TREE when this is invalid (for instance runtime is not
  85    required to implement the function call in all cases).  */
  86 tree implicit_built_in_decls[(int) END_BUILTINS];
  87
  88 static const char *c_getstr (tree);
  89 static rtx c_readstr (const char *, enum machine_mode);
  90 static int target_char_cast (tree, char *);
  91 static rtx get_memory_rtx (tree, tree);
  92 static int apply_args_size (void);
  93 static int apply_result_size (void);
  94 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
  95 static rtx result_vector (int, rtx);
  96 #endif
  97 static void expand_builtin_update_setjmp_buf (rtx);
  98 static void expand_builtin_prefetch (tree);
  99 static rtx expand_builtin_apply_args (void);
 100 static rtx expand_builtin_apply_args_1 (void);
 101 static rtx expand_builtin_apply (rtx, rtx, rtx);
 102 static void expand_builtin_return (rtx);
 103 static enum type_class type_to_class (tree);
 104 static rtx expand_builtin_classify_type (tree);
 105 static void expand_errno_check (tree, rtx);
 106 static rtx expand_builtin_mathfn (tree, rtx, rtx);
 107 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
 108 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
 109 static rtx expand_builtin_interclass_mathfn (tree, rtx);
 110 static rtx expand_builtin_sincos (tree);
 111 static rtx expand_builtin_cexpi (tree, rtx);
 112 static rtx expand_builtin_int_roundingfn (tree, rtx);
 113 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
 114 static rtx expand_builtin_next_arg (void);
 115 static rtx expand_builtin_va_start (tree);
 116 static rtx expand_builtin_va_end (tree);
 117 static rtx expand_builtin_va_copy (tree);
 118 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
 119 static rtx expand_builtin_strcmp (tree, rtx);
 120 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
 121 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 122 static rtx expand_builtin_memcpy (tree, rtx);
 123 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
 124 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
 125                                         enum machine_mode, int);
 126 static rtx expand_builtin_strcpy (tree, rtx);
 127 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
 128 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
 129 static rtx expand_builtin_strncpy (tree, rtx);
 130 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
 131 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
 132 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
 133 static rtx expand_builtin_bzero (tree);
 134 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
 135 static rtx expand_builtin_alloca (tree, rtx, bool);
 136 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
 137 static rtx expand_builtin_frame_address (tree, tree);
 138 static tree stabilize_va_list_loc (location_t, tree, int);
 139 static rtx expand_builtin_expect (tree, rtx);
 140 static tree fold_builtin_constant_p (tree);
 141 static tree fold_builtin_expect (location_t, tree, tree);
 142 static tree fold_builtin_classify_type (tree);
 143 static tree fold_builtin_strlen (location_t, tree, tree);
 144 static tree fold_builtin_inf (location_t, tree, int);
 145 static tree fold_builtin_nan (tree, tree, int);
 146 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
 147 static bool validate_arg (const_tree, enum tree_code code);
 148 static bool integer_valued_real_p (tree);
 149 static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
 150 static bool readonly_data_expr (tree);
 151 static rtx expand_builtin_fabs (tree, rtx, rtx);
 152 static rtx expand_builtin_signbit (tree, rtx);
 153 static tree fold_builtin_sqrt (location_t, tree, tree);
 154 static tree fold_builtin_cbrt (location_t, tree, tree);
 155 static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
 156 static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
 157 static tree fold_builtin_cos (location_t, tree, tree, tree);
 158 static tree fold_builtin_cosh (location_t, tree, tree, tree);
 159 static tree fold_builtin_tan (tree, tree);
 160 static tree fold_builtin_trunc (location_t, tree, tree);
 161 static tree fold_builtin_floor (location_t, tree, tree);
 162 static tree fold_builtin_ceil (location_t, tree, tree);
 163 static tree fold_builtin_round (location_t, tree, tree);
 164 static tree fold_builtin_int_roundingfn (location_t, tree, tree);
 165 static tree fold_builtin_bitop (tree, tree);
 166 static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
 167 static tree fold_builtin_strchr (location_t, tree, tree, tree);
 168 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
 169 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
 170 static tree fold_builtin_strcmp (location_t, tree, tree);
 171 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
 172 static tree fold_builtin_signbit (location_t, tree, tree);
 173 static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
 174 static tree fold_builtin_isascii (location_t, tree);
 175 static tree fold_builtin_toascii (location_t, tree);
 176 static tree fold_builtin_isdigit (location_t, tree);
 177 static tree fold_builtin_fabs (location_t, tree, tree);
 178 static tree fold_builtin_abs (location_t, tree, tree);
 179 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
 180                                         enum tree_code);
 181 static tree fold_builtin_n (location_t, tree, tree *, int, bool);
 182 static tree fold_builtin_0 (location_t, tree, bool);
 183 static tree fold_builtin_1 (location_t, tree, tree, bool);
 184 static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
 185 static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
 186 static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
 187 static tree fold_builtin_varargs (location_t, tree, tree, bool);
 188
 189 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
 190 static tree fold_builtin_strstr (location_t, tree, tree, tree);
 191 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
 192 static tree fold_builtin_strcat (location_t, tree, tree);
 193 static tree fold_builtin_strncat (location_t, tree, tree, tree);
 194 static tree fold_builtin_strspn (location_t, tree, tree);
 195 static tree fold_builtin_strcspn (location_t, tree, tree);
 196 static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
 197
 198 static rtx expand_builtin_object_size (tree);
 199 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
 200                                       enum built_in_function);
 201 static void maybe_emit_chk_warning (tree, enum built_in_function);
 202 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 203 static void maybe_emit_free_warning (tree);
 204 static tree fold_builtin_object_size (tree, tree);
 205 static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
 206 static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
 207 static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
 208 static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
 209 static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
 210                                   enum built_in_function);
 211 static bool init_target_chars (void);
 212
 213 static unsigned HOST_WIDE_INT target_newline;
 214 static unsigned HOST_WIDE_INT target_percent;
 215 static unsigned HOST_WIDE_INT target_c;
 216 static unsigned HOST_WIDE_INT target_s;
 217 static char target_percent_c[3];
 218 static char target_percent_s[3];
 219 static char target_percent_s_newline[4];
 220 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
 221                           const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
 222 static tree do_mpfr_arg2 (tree, tree, tree,
 223                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 224 static tree do_mpfr_arg3 (tree, tree, tree, tree,
 225                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 226 static tree do_mpfr_sincos (tree, tree, tree);
 227 static tree do_mpfr_bessel_n (tree, tree, tree,
 228                               int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
 229                               const REAL_VALUE_TYPE *, bool);
 230 static tree do_mpfr_remquo (tree, tree, tree);
 231 static tree do_mpfr_lgamma_r (tree, tree, tree);
 232
 233 /* Return true if NAME starts with __builtin_ or __sync_.  */
 234
 235 bool
 236 is_builtin_name (const char *name)
 237 {
 238   if (strncmp (name, "__builtin_", 10) == 0)
 239     return true;
 240   if (strncmp (name, "__sync_", 7) == 0)
 241     return true;
 242   return false;
 243 }
 244
 245
 246 /* Return true if DECL is a function symbol representing a built-in.  */
 247
 248 bool
 249 is_builtin_fn (tree decl)
 250 {
 251   return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
 252 }
 253
 254
 255 /* Return true if NODE should be considered for inline expansion regardless
 256    of the optimization level.  This means whenever a function is invoked with
 257    its "internal" name, which normally contains the prefix "__builtin".  */
 258
 259 static bool
 260 called_as_built_in (tree node)
 261 {
 262   /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
 263      we want the name used to call the function, not the name it
 264      will have. */
 265   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 266   return is_builtin_name (name);
 267 }
 268
 269 /* Return the alignment in bits of EXP, an object.
 270    Don't return more than MAX_ALIGN no matter what.  */
 271
 272 unsigned int
 273 get_object_alignment (tree exp, unsigned int max_align)
 274 {
 275   HOST_WIDE_INT bitsize, bitpos;
 276   tree offset;
 277   enum machine_mode mode;
 278   int unsignedp, volatilep;
 279   unsigned int align, inner;
 280
 281   /* Get the innermost object and the constant (bitpos) and possibly
 282      variable (offset) offset of the access.  */
 283   exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
 284                              &mode, &unsignedp, &volatilep, true);
 285
 286   /* Extract alignment information from the innermost object and
 287      possibly adjust bitpos and offset.  */
 288   if (TREE_CODE (exp) == CONST_DECL)
 289     exp = DECL_INITIAL (exp);
 290   if (DECL_P (exp)
 291       && TREE_CODE (exp) != LABEL_DECL)
 292     align = DECL_ALIGN (exp);
 293   else if (CONSTANT_CLASS_P (exp))
 294     {
 295       align = TYPE_ALIGN (TREE_TYPE (exp));
 296 #ifdef CONSTANT_ALIGNMENT
 297       align = (unsigned)CONSTANT_ALIGNMENT (exp, align);
 298 #endif
 299     }
 300   else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
 301     align = TYPE_ALIGN (TREE_TYPE (exp));
 302   else if (TREE_CODE (exp) == INDIRECT_REF)
 303     align = TYPE_ALIGN (TREE_TYPE (exp));
 304   else if (TREE_CODE (exp) == MEM_REF)
 305     {
 306       tree addr = TREE_OPERAND (exp, 0);
 307       struct ptr_info_def *pi;
 308       if (TREE_CODE (addr) == BIT_AND_EXPR
 309           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 310         {
 311           align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 312                     & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 313           align *= BITS_PER_UNIT;
 314           addr = TREE_OPERAND (addr, 0);
 315         }
 316       else
 317         align = BITS_PER_UNIT;
 318       if (TREE_CODE (addr) == SSA_NAME
 319           && (pi = SSA_NAME_PTR_INFO (addr)))
 320         {
 321           bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
 322           align = MAX (pi->align * BITS_PER_UNIT, align);
 323         }
 324       else if (TREE_CODE (addr) == ADDR_EXPR)
 325         align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
 326                                                   max_align));
 327       bitpos += mem_ref_offset (exp).low * BITS_PER_UNIT;
 328     }
 329   else if (TREE_CODE (exp) == TARGET_MEM_REF)
 330     {
 331       struct ptr_info_def *pi;
 332       tree addr = TMR_BASE (exp);
 333       if (TREE_CODE (addr) == BIT_AND_EXPR
 334           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 335         {
 336           align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 337                    & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 338           align *= BITS_PER_UNIT;
 339           addr = TREE_OPERAND (addr, 0);
 340         }
 341       else
 342         align = BITS_PER_UNIT;
 343       if (TREE_CODE (addr) == SSA_NAME
 344           && (pi = SSA_NAME_PTR_INFO (addr)))
 345         {
 346           bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
 347           align = MAX (pi->align * BITS_PER_UNIT, align);
 348         }
 349       else if (TREE_CODE (addr) == ADDR_EXPR)
 350         align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
 351                                                   max_align));
 352       if (TMR_OFFSET (exp))
 353         bitpos += TREE_INT_CST_LOW (TMR_OFFSET (exp)) * BITS_PER_UNIT;
 354       if (TMR_INDEX (exp) && TMR_STEP (exp))
 355         {
 356           unsigned HOST_WIDE_INT step = TREE_INT_CST_LOW (TMR_STEP (exp));
 357           align = MIN (align, (step & -step) * BITS_PER_UNIT);
 358         }
 359       else if (TMR_INDEX (exp))
 360         align = BITS_PER_UNIT;
 361       if (TMR_INDEX2 (exp))
 362         align = BITS_PER_UNIT;
 363     }
 364   else
 365     align = BITS_PER_UNIT;
 366
 367   /* If there is a non-constant offset part extract the maximum
 368      alignment that can prevail.  */
 369   inner = max_align;
 370   while (offset)
 371     {
 372       tree next_offset;
 373
 374       if (TREE_CODE (offset) == PLUS_EXPR)
 375         {
 376           next_offset = TREE_OPERAND (offset, 0);
 377           offset = TREE_OPERAND (offset, 1);
 378         }
 379       else
 380         next_offset = NULL;
 381       if (host_integerp (offset, 1))
 382         {
 383           /* Any overflow in calculating offset_bits won't change
 384              the alignment.  */
 385           unsigned offset_bits
 386             = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
 387
 388           if (offset_bits)
 389             inner = MIN (inner, (offset_bits & -offset_bits));
 390         }
 391       else if (TREE_CODE (offset) == MULT_EXPR
 392                && host_integerp (TREE_OPERAND (offset, 1), 1))
 393         {
 394           /* Any overflow in calculating offset_factor won't change
 395              the alignment.  */
 396           unsigned offset_factor
 397             = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
 398                * BITS_PER_UNIT);
 399
 400           if (offset_factor)
 401             inner = MIN (inner, (offset_factor & -offset_factor));
 402         }
 403       else
 404         {
 405           inner = MIN (inner, BITS_PER_UNIT);
 406           break;
 407         }
 408       offset = next_offset;
 409     }
 410
 411   /* Alignment is innermost object alignment adjusted by the constant
 412      and non-constant offset parts.  */
 413   align = MIN (align, inner);
 414   bitpos = bitpos & (align - 1);
 415
 416   /* align and bitpos now specify known low bits of the pointer.
 417      ptr & (align - 1) == bitpos.  */
 418
 419   if (bitpos != 0)
 420     align = (bitpos & -bitpos);
 421
 422   return MIN (align, max_align);
 423 }
 424
 425 /* Returns true iff we can trust that alignment information has been
 426    calculated properly.  */
 427
 428 bool
 429 can_trust_pointer_alignment (void)
 430 {
 431   /* We rely on TER to compute accurate alignment information.  */
 432   return (optimize && flag_tree_ter);
 433 }
 434
 435 /* Return the alignment in bits of EXP, a pointer valued expression.
 436    But don't return more than MAX_ALIGN no matter what.
 437    The alignment returned is, by default, the alignment of the thing that
 438    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 439
 440    Otherwise, look at the expression to see if we can do better, i.e., if the
 441    expression is actually pointing at an object whose alignment is tighter.  */
 442
 443 unsigned int
 444 get_pointer_alignment (tree exp, unsigned int max_align)
 445 {
 446   STRIP_NOPS (exp);
 447
 448   if (TREE_CODE (exp) == ADDR_EXPR)
 449     return get_object_alignment (TREE_OPERAND (exp, 0), max_align);
 450   else if (TREE_CODE (exp) == SSA_NAME
 451            && POINTER_TYPE_P (TREE_TYPE (exp)))
 452     {
 453       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);
 454       unsigned align;
 455       if (!pi)
 456         return BITS_PER_UNIT;
 457       if (pi->misalign != 0)
 458         align = (pi->misalign & -pi->misalign);
 459       else
 460         align = pi->align;
 461       return MIN (max_align, align * BITS_PER_UNIT);
 462     }
 463
 464   return POINTER_TYPE_P (TREE_TYPE (exp)) ? BITS_PER_UNIT : 0;
 465 }
 466
 467 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 468    way, because it could contain a zero byte in the middle.
 469    TREE_STRING_LENGTH is the size of the character array, not the string.
 470
 471    ONLY_VALUE should be nonzero if the result is not going to be emitted
 472    into the instruction stream and zero if it is going to be expanded.
 473    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 474    is returned, otherwise NULL, since
 475    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
 476    evaluate the side-effects.
 477
 478    The value returned is of type `ssizetype'.
 479
 480    Unfortunately, string_constant can't access the values of const char
 481    arrays with initializers, so neither can we do so here.  */
 482
 483 tree
 484 c_strlen (tree src, int only_value)
 485 {
 486   tree offset_node;
 487   HOST_WIDE_INT offset;
 488   int max;
 489   const char *ptr;
 490   location_t loc;
 491
 492   STRIP_NOPS (src);
 493   if (TREE_CODE (src) == COND_EXPR
 494       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 495     {
 496       tree len1, len2;
 497
 498       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
 499       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
 500       if (tree_int_cst_equal (len1, len2))
 501         return len1;
 502     }
 503
 504   if (TREE_CODE (src) == COMPOUND_EXPR
 505       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 506     return c_strlen (TREE_OPERAND (src, 1), only_value);
 507
 508   if (EXPR_HAS_LOCATION (src))
 509     loc = EXPR_LOCATION (src);
 510   else
 511     loc = input_location;
 512
 513   src = string_constant (src, &offset_node);
 514   if (src == 0)
 515     return NULL_TREE;
 516
 517   max = TREE_STRING_LENGTH (src) - 1;
 518   ptr = TREE_STRING_POINTER (src);
 519
 520   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 521     {
 522       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 523          compute the offset to the following null if we don't know where to
 524          start searching for it.  */
 525       int i;
 526
 527       for (i = 0; i < max; i++)
 528         if (ptr[i] == 0)
 529           return NULL_TREE;
 530
 531       /* We don't know the starting offset, but we do know that the string
 532          has no internal zero bytes.  We can assume that the offset falls
 533          within the bounds of the string; otherwise, the programmer deserves
 534          what he gets.  Subtract the offset from the length of the string,
 535          and return that.  This would perhaps not be valid if we were dealing
 536          with named arrays in addition to literal string constants.  */
 537
 538       return size_diffop_loc (loc, size_int (max), offset_node);
 539     }
 540
 541   /* We have a known offset into the string.  Start searching there for
 542      a null character if we can represent it as a single HOST_WIDE_INT.  */
 543   if (offset_node == 0)
 544     offset = 0;
 545   else if (! host_integerp (offset_node, 0))
 546     offset = -1;
 547   else
 548     offset = tree_low_cst (offset_node, 0);
 549
 550   /* If the offset is known to be out of bounds, warn, and call strlen at
 551      runtime.  */
 552   if (offset < 0 || offset > max)
 553     {
 554      /* Suppress multiple warnings for propagated constant strings.  */
 555       if (! TREE_NO_WARNING (src))
 556         {
 557           warning_at (loc, 0, "offset outside bounds of constant string");
 558           TREE_NO_WARNING (src) = 1;
 559         }
 560       return NULL_TREE;
 561     }
 562
 563   /* Use strlen to search for the first zero byte.  Since any strings
 564      constructed with build_string will have nulls appended, we win even
 565      if we get handed something like (char[4])"abcd".
 566
 567      Since OFFSET is our starting index into the string, no further
 568      calculation is needed.  */
 569   return ssize_int (strlen (ptr + offset));
 570 }
 571
 572 /* Return a char pointer for a C string if it is a string constant
 573    or sum of string constant and integer constant.  */
 574
 575 static const char *
 576 c_getstr (tree src)
 577 {
 578   tree offset_node;
 579
 580   src = string_constant (src, &offset_node);
 581   if (src == 0)
 582     return 0;
 583
 584   if (offset_node == 0)
 585     return TREE_STRING_POINTER (src);
 586   else if (!host_integerp (offset_node, 1)
 587            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
 588     return 0;
 589
 590   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
 591 }
 592
 593 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
 594    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 595
 596 static rtx
 597 c_readstr (const char *str, enum machine_mode mode)
 598 {
 599   HOST_WIDE_INT c[2];
 600   HOST_WIDE_INT ch;
 601   unsigned int i, j;
 602
 603   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
 604
 605   c[0] = 0;
 606   c[1] = 0;
 607   ch = 1;
 608   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 609     {
 610       j = i;
 611       if (WORDS_BIG_ENDIAN)
 612         j = GET_MODE_SIZE (mode) - i - 1;
 613       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 614           && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
 615         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 616       j *= BITS_PER_UNIT;
 617       gcc_assert (j < 2 * HOST_BITS_PER_WIDE_INT);
 618
 619       if (ch)
 620         ch = (unsigned char) str[i];
 621       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 622     }
 623   return immed_double_const (c[0], c[1], mode);
 624 }
 625
 626 /* Cast a target constant CST to target CHAR and if that value fits into
 627    host char type, return zero and put that value into variable pointed to by
 628    P.  */
 629
 630 static int
 631 target_char_cast (tree cst, char *p)
 632 {
 633   unsigned HOST_WIDE_INT val, hostval;
 634
 635   if (!host_integerp (cst, 1)
 636       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 637     return 1;
 638
 639   val = tree_low_cst (cst, 1);
 640   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 641     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 642
 643   hostval = val;
 644   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 645     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 646
 647   if (val != hostval)
 648     return 1;
 649
 650   *p = hostval;
 651   return 0;
 652 }
 653
 654 /* Similar to save_expr, but assumes that arbitrary code is not executed
 655    in between the multiple evaluations.  In particular, we assume that a
 656    non-addressable local variable will not be modified.  */
 657
 658 static tree
 659 builtin_save_expr (tree exp)
 660 {
 661   if (TREE_ADDRESSABLE (exp) == 0
 662       && (TREE_CODE (exp) == PARM_DECL
 663           || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
 664     return exp;
 665
 666   return save_expr (exp);
 667 }
 668
 669 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 670    times to get the address of either a higher stack frame, or a return
 671    address located within it (depending on FNDECL_CODE).  */
 672
 673 static rtx
 674 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
 675 {
 676   int i;
 677
 678 #ifdef INITIAL_FRAME_ADDRESS_RTX
 679   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
 680 #else
 681   rtx tem;
 682
 683   /* For a zero count with __builtin_return_address, we don't care what
 684      frame address we return, because target-specific definitions will
 685      override us.  Therefore frame pointer elimination is OK, and using
 686      the soft frame pointer is OK.
 687
 688      For a nonzero count, or a zero count with __builtin_frame_address,
 689      we require a stable offset from the current frame pointer to the
 690      previous one, so we must use the hard frame pointer, and
 691      we must disable frame pointer elimination.  */
 692   if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
 693     tem = frame_pointer_rtx;
 694   else
 695     {
 696       tem = hard_frame_pointer_rtx;
 697
 698       /* Tell reload not to eliminate the frame pointer.  */
 699       crtl->accesses_prior_frames = 1;
 700     }
 701 #endif
 702
 703   /* Some machines need special handling before we can access
 704      arbitrary frames.  For example, on the SPARC, we must first flush
 705      all register windows to the stack.  */
 706 #ifdef SETUP_FRAME_ADDRESSES
 707   if (count > 0)
 708     SETUP_FRAME_ADDRESSES ();
 709 #endif
 710
 711   /* On the SPARC, the return address is not in the frame, it is in a
 712      register.  There is no way to access it off of the current frame
 713      pointer, but it can be accessed off the previous frame pointer by
 714      reading the value from the register window save area.  */
 715 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
 716   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
 717     count--;
 718 #endif
 719
 720   /* Scan back COUNT frames to the specified frame.  */
 721   for (i = 0; i < count; i++)
 722     {
 723       /* Assume the dynamic chain pointer is in the word that the
 724          frame address points to, unless otherwise specified.  */
 725 #ifdef DYNAMIC_CHAIN_ADDRESS
 726       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 727 #endif
 728       tem = memory_address (Pmode, tem);
 729       tem = gen_frame_mem (Pmode, tem);
 730       tem = copy_to_reg (tem);
 731     }
 732
 733   /* For __builtin_frame_address, return what we've got.  But, on
 734      the SPARC for example, we may have to add a bias.  */
 735   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 736 #ifdef FRAME_ADDR_RTX
 737     return FRAME_ADDR_RTX (tem);
 738 #else
 739     return tem;
 740 #endif
 741
 742   /* For __builtin_return_address, get the return address from that frame.  */
 743 #ifdef RETURN_ADDR_RTX
 744   tem = RETURN_ADDR_RTX (count, tem);
 745 #else
 746   tem = memory_address (Pmode,
 747                         plus_constant (tem, GET_MODE_SIZE (Pmode)));
 748   tem = gen_frame_mem (Pmode, tem);
 749 #endif
 750   return tem;
 751 }
 752
 753 /* Alias set used for setjmp buffer.  */
 754 static alias_set_type setjmp_alias_set = -1;
 755
 756 /* Construct the leading half of a __builtin_setjmp call.  Control will
 757    return to RECEIVER_LABEL.  This is also called directly by the SJLJ
 758    exception handling code.  */
 759
 760 void
 761 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 762 {
 763   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 764   rtx stack_save;
 765   rtx mem;
 766
 767   if (setjmp_alias_set == -1)
 768     setjmp_alias_set = new_alias_set ();
 769
 770   buf_addr = convert_memory_address (Pmode, buf_addr);
 771
 772   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 773
 774   /* We store the frame pointer and the address of receiver_label in
 775      the buffer and use the rest of it for the stack save area, which
 776      is machine-dependent.  */
 777
 778   mem = gen_rtx_MEM (Pmode, buf_addr);
 779   set_mem_alias_set (mem, setjmp_alias_set);
 780   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
 781
 782   mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
 783   set_mem_alias_set (mem, setjmp_alias_set);
 784
 785   emit_move_insn (validize_mem (mem),
 786                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 787
 788   stack_save = gen_rtx_MEM (sa_mode,
 789                             plus_constant (buf_addr,
 790                                            2 * GET_MODE_SIZE (Pmode)));
 791   set_mem_alias_set (stack_save, setjmp_alias_set);
 792   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
 793
 794   /* If there is further processing to do, do it.  */
 795 #ifdef HAVE_builtin_setjmp_setup
 796   if (HAVE_builtin_setjmp_setup)
 797     emit_insn (gen_builtin_setjmp_setup (buf_addr));
 798 #endif
 799
 800   /* Tell optimize_save_area_alloca that extra work is going to
 801      need to go on during alloca.  */
 802   cfun->calls_setjmp = 1;
 803
 804   /* We have a nonlocal label.   */
 805   cfun->has_nonlocal_label = 1;
 806 }
 807
 808 /* Construct the trailing part of a __builtin_setjmp call.  This is
 809    also called directly by the SJLJ exception handling code.  */
 810
 811 void
 812 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
 813 {
 814   rtx chain;
 815
 816   /* Clobber the FP when we get here, so we have to make sure it's
 817      marked as used by this function.  */
 818   emit_use (hard_frame_pointer_rtx);
 819
 820   /* Mark the static chain as clobbered here so life information
 821      doesn't get messed up for it.  */
 822   chain = targetm.calls.static_chain (current_function_decl, true);
 823   if (chain && REG_P (chain))
 824     emit_clobber (chain);
 825
 826   /* Now put in the code to restore the frame pointer, and argument
 827      pointer, if needed.  */
 828 #ifdef HAVE_nonlocal_goto
 829   if (! HAVE_nonlocal_goto)
 830 #endif
 831     {
 832       emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 833       /* This might change the hard frame pointer in ways that aren't
 834          apparent to early optimization passes, so force a clobber.  */
 835       emit_clobber (hard_frame_pointer_rtx);
 836     }
 837
 838 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 839   if (fixed_regs[ARG_POINTER_REGNUM])
 840     {
 841 #ifdef ELIMINABLE_REGS
 842       size_t i;
 843       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 844
 845       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 846         if (elim_regs[i].from == ARG_POINTER_REGNUM
 847             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 848           break;
 849
 850       if (i == ARRAY_SIZE (elim_regs))
 851 #endif
 852         {
 853           /* Now restore our arg pointer from the address at which it
 854              was saved in our stack frame.  */
 855           emit_move_insn (crtl->args.internal_arg_pointer,
 856                           copy_to_reg (get_arg_pointer_save_area ()));
 857         }
 858     }
 859 #endif
 860
 861 #ifdef HAVE_builtin_setjmp_receiver
 862   if (HAVE_builtin_setjmp_receiver)
 863     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
 864   else
 865 #endif
 866 #ifdef HAVE_nonlocal_goto_receiver
 867     if (HAVE_nonlocal_goto_receiver)
 868       emit_insn (gen_nonlocal_goto_receiver ());
 869     else
 870 #endif
 871       { /* Nothing */ }
 872
 873   /* We must not allow the code we just generated to be reordered by
 874      scheduling.  Specifically, the update of the frame pointer must
 875      happen immediately, not later.  */
 876   emit_insn (gen_blockage ());
 877 }
 878
 879 /* __builtin_longjmp is passed a pointer to an array of five words (not
 880    all will be used on all machines).  It operates similarly to the C
 881    library function of the same name, but is more efficient.  Much of
 882    the code below is copied from the handling of non-local gotos.  */
 883
 884 static void
 885 expand_builtin_longjmp (rtx buf_addr, rtx value)
 886 {
 887   rtx fp, lab, stack, insn, last;
 888   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 889
 890   /* DRAP is needed for stack realign if longjmp is expanded to current
 891      function  */
 892   if (SUPPORTS_STACK_ALIGNMENT)
 893     crtl->need_drap = true;
 894
 895   if (setjmp_alias_set == -1)
 896     setjmp_alias_set = new_alias_set ();
 897
 898   buf_addr = convert_memory_address (Pmode, buf_addr);
 899
 900   buf_addr = force_reg (Pmode, buf_addr);
 901
 902   /* We require that the user must pass a second argument of 1, because
 903      that is what builtin_setjmp will return.  */
 904   gcc_assert (value == const1_rtx);
 905
 906   last = get_last_insn ();
 907 #ifdef HAVE_builtin_longjmp
 908   if (HAVE_builtin_longjmp)
 909     emit_insn (gen_builtin_longjmp (buf_addr));
 910   else
 911 #endif
 912     {
 913       fp = gen_rtx_MEM (Pmode, buf_addr);
 914       lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
 915                                                GET_MODE_SIZE (Pmode)));
 916
 917       stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
 918                                                    2 * GET_MODE_SIZE (Pmode)));
 919       set_mem_alias_set (fp, setjmp_alias_set);
 920       set_mem_alias_set (lab, setjmp_alias_set);
 921       set_mem_alias_set (stack, setjmp_alias_set);
 922
 923       /* Pick up FP, label, and SP from the block and jump.  This code is
 924          from expand_goto in stmt.c; see there for detailed comments.  */
 925 #ifdef HAVE_nonlocal_goto
 926       if (HAVE_nonlocal_goto)
 927         /* We have to pass a value to the nonlocal_goto pattern that will
 928            get copied into the static_chain pointer, but it does not matter
 929            what that value is, because builtin_setjmp does not use it.  */
 930         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
 931       else
 932 #endif
 933         {
 934           lab = copy_to_reg (lab);
 935
 936           emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 937           emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 938
 939           emit_move_insn (hard_frame_pointer_rtx, fp);
 940           emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
 941
 942           emit_use (hard_frame_pointer_rtx);
 943           emit_use (stack_pointer_rtx);
 944           emit_indirect_jump (lab);
 945         }
 946     }
 947
 948   /* Search backwards and mark the jump insn as a non-local goto.
 949      Note that this precludes the use of __builtin_longjmp to a
 950      __builtin_setjmp target in the same function.  However, we've
 951      already cautioned the user that these functions are for
 952      internal exception handling use only.  */
 953   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 954     {
 955       gcc_assert (insn != last);
 956
 957       if (JUMP_P (insn))
 958         {
 959           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
 960           break;
 961         }
 962       else if (CALL_P (insn))
 963         break;
 964     }
 965 }
 966
 967 /* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
 968    and the address of the save area.  */
 969
 970 static rtx
 971 expand_builtin_nonlocal_goto (tree exp)
 972 {
 973   tree t_label, t_save_area;
 974   rtx r_label, r_save_area, r_fp, r_sp, insn;
 975
 976   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
 977     return NULL_RTX;
 978
 979   t_label = CALL_EXPR_ARG (exp, 0);
 980   t_save_area = CALL_EXPR_ARG (exp, 1);
 981
 982   r_label = expand_normal (t_label);
 983   r_label = convert_memory_address (Pmode, r_label);
 984   r_save_area = expand_normal (t_save_area);
 985   r_save_area = convert_memory_address (Pmode, r_save_area);
 986   /* Copy the address of the save location to a register just in case it was based
 987     on the frame pointer.   */
 988   r_save_area = copy_to_reg (r_save_area);
 989   r_fp = gen_rtx_MEM (Pmode, r_save_area);
 990   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
 991                       plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
 992
 993   crtl->has_nonlocal_goto = 1;
 994
 995 #ifdef HAVE_nonlocal_goto
 996   /* ??? We no longer need to pass the static chain value, afaik.  */
 997   if (HAVE_nonlocal_goto)
 998     emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
 999   else
1000 #endif
1001     {
1002       r_label = copy_to_reg (r_label);
1003
1004       emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1005       emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1006
1007       /* Restore frame pointer for containing function.
1008          This sets the actual hard register used for the frame pointer
1009          to the location of the function's incoming static chain info.
1010          The non-local goto handler will then adjust it to contain the
1011          proper value and reload the argument pointer, if needed.  */
1012       emit_move_insn (hard_frame_pointer_rtx, r_fp);
1013       emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
1014
1015       /* USE of hard_frame_pointer_rtx added for consistency;
1016          not clear if really needed.  */
1017       emit_use (hard_frame_pointer_rtx);
1018       emit_use (stack_pointer_rtx);
1019
1020       /* If the architecture is using a GP register, we must
1021          conservatively assume that the target function makes use of it.
1022          The prologue of functions with nonlocal gotos must therefore
1023          initialize the GP register to the appropriate value, and we
1024          must then make sure that this value is live at the point
1025          of the jump.  (Note that this doesn't necessarily apply
1026          to targets with a nonlocal_goto pattern; they are free
1027          to implement it in their own way.  Note also that this is
1028          a no-op if the GP register is a global invariant.)  */
1029       if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
1030           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
1031         emit_use (pic_offset_table_rtx);
1032
1033       emit_indirect_jump (r_label);
1034     }
1035
1036   /* Search backwards to the jump insn and mark it as a
1037      non-local goto.  */
1038   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1039     {
1040       if (JUMP_P (insn))
1041         {
1042           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1043           break;
1044         }
1045       else if (CALL_P (insn))
1046         break;
1047     }
1048
1049   return const0_rtx;
1050 }
1051
1052 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1053    (not all will be used on all machines) that was passed to __builtin_setjmp.
1054    It updates the stack pointer in that block to correspond to the current
1055    stack pointer.  */
1056
1057 static void
1058 expand_builtin_update_setjmp_buf (rtx buf_addr)
1059 {
1060   enum machine_mode sa_mode = Pmode;
1061   rtx stack_save;
1062
1063
1064 #ifdef HAVE_save_stack_nonlocal
1065   if (HAVE_save_stack_nonlocal)
1066     sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
1067 #endif
1068 #ifdef STACK_SAVEAREA_MODE
1069   sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1070 #endif
1071
1072   stack_save
1073     = gen_rtx_MEM (sa_mode,
1074                    memory_address
1075                    (sa_mode,
1076                     plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1077
1078 #ifdef HAVE_setjmp
1079   if (HAVE_setjmp)
1080     emit_insn (gen_setjmp ());
1081 #endif
1082
1083   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
1084 }
1085
1086 /* Expand a call to __builtin_prefetch.  For a target that does not support
1087    data prefetch, evaluate the memory address argument in case it has side
1088    effects.  */
1089
1090 static void
1091 expand_builtin_prefetch (tree exp)
1092 {
1093   tree arg0, arg1, arg2;
1094   int nargs;
1095   rtx op0, op1, op2;
1096
1097   if (!validate_arglist (exp, POINTER_TYPE, 0))
1098     return;
1099
1100   arg0 = CALL_EXPR_ARG (exp, 0);
1101
1102   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1103      zero (read) and argument 2 (locality) defaults to 3 (high degree of
1104      locality).  */
1105   nargs = call_expr_nargs (exp);
1106   if (nargs > 1)
1107     arg1 = CALL_EXPR_ARG (exp, 1);
1108   else
1109     arg1 = integer_zero_node;
1110   if (nargs > 2)
1111     arg2 = CALL_EXPR_ARG (exp, 2);
1112   else
1113     arg2 = integer_three_node;
1114
1115   /* Argument 0 is an address.  */
1116   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1117
1118   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
1119   if (TREE_CODE (arg1) != INTEGER_CST)
1120     {
1121       error ("second argument to %<__builtin_prefetch%> must be a constant");
1122       arg1 = integer_zero_node;
1123     }
1124   op1 = expand_normal (arg1);
1125   /* Argument 1 must be either zero or one.  */
1126   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1127     {
1128       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1129                " using zero");
1130       op1 = const0_rtx;
1131     }
1132
1133   /* Argument 2 (locality) must be a compile-time constant int.  */
1134   if (TREE_CODE (arg2) != INTEGER_CST)
1135     {
1136       error ("third argument to %<__builtin_prefetch%> must be a constant");
1137       arg2 = integer_zero_node;
1138     }
1139   op2 = expand_normal (arg2);
1140   /* Argument 2 must be 0, 1, 2, or 3.  */
1141   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1142     {
1143       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1144       op2 = const0_rtx;
1145     }
1146
1147 #ifdef HAVE_prefetch
1148   if (HAVE_prefetch)
1149     {
1150       if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
1151              (op0,
1152               insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1153           || (GET_MODE (op0) != Pmode))
1154         {
1155           op0 = convert_memory_address (Pmode, op0);
1156           op0 = force_reg (Pmode, op0);
1157         }
1158       emit_insn (gen_prefetch (op0, op1, op2));
1159     }
1160 #endif
1161
1162   /* Don't do anything with direct references to volatile memory, but
1163      generate code to handle other side effects.  */
1164   if (!MEM_P (op0) && side_effects_p (op0))
1165     emit_insn (op0);
1166 }
1167
1168 /* Get a MEM rtx for expression EXP which is the address of an operand
1169    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1170    the maximum length of the block of memory that might be accessed or
1171    NULL if unknown.  */
1172
1173 static rtx
1174 get_memory_rtx (tree exp, tree len)
1175 {
1176   tree orig_exp = exp;
1177   rtx addr, mem;
1178   HOST_WIDE_INT off;
1179
1180   /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1181      from its expression, for expr->a.b only <variable>.a.b is recorded.  */
1182   if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1183     exp = TREE_OPERAND (exp, 0);
1184
1185   addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1186   mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1187
1188   /* Get an expression we can use to find the attributes to assign to MEM.
1189      If it is an ADDR_EXPR, use the operand.  Otherwise, dereference it if
1190      we can.  First remove any nops.  */
1191   while (CONVERT_EXPR_P (exp)
1192          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1193     exp = TREE_OPERAND (exp, 0);
1194
1195   off = 0;
1196   if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1197       && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1198       && host_integerp (TREE_OPERAND (exp, 1), 0)
1199       && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1200     exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1201   else if (TREE_CODE (exp) == ADDR_EXPR)
1202     exp = TREE_OPERAND (exp, 0);
1203   else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1204     exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1205   else
1206     exp = NULL;
1207
1208   /* Honor attributes derived from exp, except for the alias set
1209      (as builtin stringops may alias with anything) and the size
1210      (as stringops may access multiple array elements).  */
1211   if (exp)
1212     {
1213       set_mem_attributes (mem, exp, 0);
1214
1215       if (off)
1216         mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1217
1218       /* Allow the string and memory builtins to overflow from one
1219          field into another, see http://gcc.gnu.org/PR23561.
1220          Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1221          memory accessed by the string or memory builtin will fit
1222          within the field.  */
1223       if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1224         {
1225           tree mem_expr = MEM_EXPR (mem);
1226           HOST_WIDE_INT offset = -1, length = -1;
1227           tree inner = exp;
1228
1229           while (TREE_CODE (inner) == ARRAY_REF
1230                  || CONVERT_EXPR_P (inner)
1231                  || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1232                  || TREE_CODE (inner) == SAVE_EXPR)
1233             inner = TREE_OPERAND (inner, 0);
1234
1235           gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1236
1237           if (MEM_OFFSET (mem)
1238               && CONST_INT_P (MEM_OFFSET (mem)))
1239             offset = INTVAL (MEM_OFFSET (mem));
1240
1241           if (offset >= 0 && len && host_integerp (len, 0))
1242             length = tree_low_cst (len, 0);
1243
1244           while (TREE_CODE (inner) == COMPONENT_REF)
1245             {
1246               tree field = TREE_OPERAND (inner, 1);
1247               gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1248               gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1249
1250               /* Bitfields are generally not byte-addressable.  */
1251               gcc_assert (!DECL_BIT_FIELD (field)
1252                           || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1253                                % BITS_PER_UNIT) == 0
1254                               && host_integerp (DECL_SIZE (field), 0)
1255                               && (TREE_INT_CST_LOW (DECL_SIZE (field))
1256                                   % BITS_PER_UNIT) == 0));
1257
1258               /* If we can prove that the memory starting at XEXP (mem, 0) and
1259                  ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1260                  can keep the COMPONENT_REF in MEM_EXPR.  But be careful with
1261                  fields without DECL_SIZE_UNIT like flexible array members.  */
1262               if (length >= 0
1263                   && DECL_SIZE_UNIT (field)
1264                   && host_integerp (DECL_SIZE_UNIT (field), 0))
1265                 {
1266                   HOST_WIDE_INT size
1267                     = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1268                   if (offset <= size
1269                       && length <= size
1270                       && offset + length <= size)
1271                     break;
1272                 }
1273
1274               if (offset >= 0
1275                   && host_integerp (DECL_FIELD_OFFSET (field), 0))
1276                 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1277                           + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1278                             / BITS_PER_UNIT;
1279               else
1280                 {
1281                   offset = -1;
1282                   length = -1;
1283                 }
1284
1285               mem_expr = TREE_OPERAND (mem_expr, 0);
1286               inner = TREE_OPERAND (inner, 0);
1287             }
1288
1289           if (mem_expr == NULL)
1290             offset = -1;
1291           if (mem_expr != MEM_EXPR (mem))
1292             {
1293               set_mem_expr (mem, mem_expr);
1294               set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1295             }
1296         }
1297       set_mem_alias_set (mem, 0);
1298       set_mem_size (mem, NULL_RTX);
1299     }
1300
1301   return mem;
1302 }
1303 \f
1304 /* Built-in functions to perform an untyped call and return.  */
1305
1306 #define apply_args_mode \
1307   (this_target_builtins->x_apply_args_mode)
1308 #define apply_result_mode \
1309   (this_target_builtins->x_apply_result_mode)
1310
1311 /* Return the size required for the block returned by __builtin_apply_args,
1312    and initialize apply_args_mode.  */
1313
1314 static int
1315 apply_args_size (void)
1316 {
1317   static int size = -1;
1318   int align;
1319   unsigned int regno;
1320   enum machine_mode mode;
1321
1322   /* The values computed by this function never change.  */
1323   if (size < 0)
1324     {
1325       /* The first value is the incoming arg-pointer.  */
1326       size = GET_MODE_SIZE (Pmode);
1327
1328       /* The second value is the structure value address unless this is
1329          passed as an "invisible" first argument.  */
1330       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1331         size += GET_MODE_SIZE (Pmode);
1332
1333       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1334         if (FUNCTION_ARG_REGNO_P (regno))
1335           {
1336             mode = reg_raw_mode[regno];
1337
1338             gcc_assert (mode != VOIDmode);
1339
1340             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1341             if (size % align != 0)
1342               size = CEIL (size, align) * align;
1343             size += GET_MODE_SIZE (mode);
1344             apply_args_mode[regno] = mode;
1345           }
1346         else
1347           {
1348             apply_args_mode[regno] = VOIDmode;
1349           }
1350     }
1351   return size;
1352 }
1353
1354 /* Return the size required for the block returned by __builtin_apply,
1355    and initialize apply_result_mode.  */
1356
1357 static int
1358 apply_result_size (void)
1359 {
1360   static int size = -1;
1361   int align, regno;
1362   enum machine_mode mode;
1363
1364   /* The values computed by this function never change.  */
1365   if (size < 0)
1366     {
1367       size = 0;
1368
1369       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1370         if (targetm.calls.function_value_regno_p (regno))
1371           {
1372             mode = reg_raw_mode[regno];
1373
1374             gcc_assert (mode != VOIDmode);
1375
1376             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1377             if (size % align != 0)
1378               size = CEIL (size, align) * align;
1379             size += GET_MODE_SIZE (mode);
1380             apply_result_mode[regno] = mode;
1381           }
1382         else
1383           apply_result_mode[regno] = VOIDmode;
1384
1385       /* Allow targets that use untyped_call and untyped_return to override
1386          the size so that machine-specific information can be stored here.  */
1387 #ifdef APPLY_RESULT_SIZE
1388       size = APPLY_RESULT_SIZE;
1389 #endif
1390     }
1391   return size;
1392 }
1393
1394 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1395 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1396    the result block is used to save the values; otherwise it is used to
1397    restore the values.  */
1398
1399 static rtx
1400 result_vector (int savep, rtx result)
1401 {
1402   int regno, size, align, nelts;
1403   enum machine_mode mode;
1404   rtx reg, mem;
1405   rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1406
1407   size = nelts = 0;
1408   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1409     if ((mode = apply_result_mode[regno]) != VOIDmode)
1410       {
1411         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1412         if (size % align != 0)
1413           size = CEIL (size, align) * align;
1414         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1415         mem = adjust_address (result, mode, size);
1416         savevec[nelts++] = (savep
1417                             ? gen_rtx_SET (VOIDmode, mem, reg)
1418                             : gen_rtx_SET (VOIDmode, reg, mem));
1419         size += GET_MODE_SIZE (mode);
1420       }
1421   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1422 }
1423 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1424
1425 /* Save the state required to perform an untyped call with the same
1426    arguments as were passed to the current function.  */
1427
1428 static rtx
1429 expand_builtin_apply_args_1 (void)
1430 {
1431   rtx registers, tem;
1432   int size, align, regno;
1433   enum machine_mode mode;
1434   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1435
1436   /* Create a block where the arg-pointer, structure value address,
1437      and argument registers can be saved.  */
1438   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1439
1440   /* Walk past the arg-pointer and structure value address.  */
1441   size = GET_MODE_SIZE (Pmode);
1442   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1443     size += GET_MODE_SIZE (Pmode);
1444
1445   /* Save each register used in calling a function to the block.  */
1446   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1447     if ((mode = apply_args_mode[regno]) != VOIDmode)
1448       {
1449         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1450         if (size % align != 0)
1451           size = CEIL (size, align) * align;
1452
1453         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1454
1455         emit_move_insn (adjust_address (registers, mode, size), tem);
1456         size += GET_MODE_SIZE (mode);
1457       }
1458
1459   /* Save the arg pointer to the block.  */
1460   tem = copy_to_reg (crtl->args.internal_arg_pointer);
1461 #ifdef STACK_GROWS_DOWNWARD
1462   /* We need the pointer as the caller actually passed them to us, not
1463      as we might have pretended they were passed.  Make sure it's a valid
1464      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1465   tem
1466     = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1467                      NULL_RTX);
1468 #endif
1469   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1470
1471   size = GET_MODE_SIZE (Pmode);
1472
1473   /* Save the structure value address unless this is passed as an
1474      "invisible" first argument.  */
1475   if (struct_incoming_value)
1476     {
1477       emit_move_insn (adjust_address (registers, Pmode, size),
1478                       copy_to_reg (struct_incoming_value));
1479       size += GET_MODE_SIZE (Pmode);
1480     }
1481
1482   /* Return the address of the block.  */
1483   return copy_addr_to_reg (XEXP (registers, 0));
1484 }
1485
1486 /* __builtin_apply_args returns block of memory allocated on
1487    the stack into which is stored the arg pointer, structure
1488    value address, static chain, and all the registers that might
1489    possibly be used in performing a function call.  The code is
1490    moved to the start of the function so the incoming values are
1491    saved.  */
1492
1493 static rtx
1494 expand_builtin_apply_args (void)
1495 {
1496   /* Don't do __builtin_apply_args more than once in a function.
1497      Save the result of the first call and reuse it.  */
1498   if (apply_args_value != 0)
1499     return apply_args_value;
1500   {
1501     /* When this function is called, it means that registers must be
1502        saved on entry to this function.  So we migrate the
1503        call to the first insn of this function.  */
1504     rtx temp;
1505     rtx seq;
1506
1507     start_sequence ();
1508     temp = expand_builtin_apply_args_1 ();
1509     seq = get_insns ();
1510     end_sequence ();
1511
1512     apply_args_value = temp;
1513
1514     /* Put the insns after the NOTE that starts the function.
1515        If this is inside a start_sequence, make the outer-level insn
1516        chain current, so the code is placed at the start of the
1517        function.  If internal_arg_pointer is a non-virtual pseudo,
1518        it needs to be placed after the function that initializes
1519        that pseudo.  */
1520     push_topmost_sequence ();
1521     if (REG_P (crtl->args.internal_arg_pointer)
1522         && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1523       emit_insn_before (seq, parm_birth_insn);
1524     else
1525       emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1526     pop_topmost_sequence ();
1527     return temp;
1528   }
1529 }
1530
1531 /* Perform an untyped call and save the state required to perform an
1532    untyped return of whatever value was returned by the given function.  */
1533
1534 static rtx
1535 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1536 {
1537   int size, align, regno;
1538   enum machine_mode mode;
1539   rtx incoming_args, result, reg, dest, src, call_insn;
1540   rtx old_stack_level = 0;
1541   rtx call_fusage = 0;
1542   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1543
1544   arguments = convert_memory_address (Pmode, arguments);
1545
1546   /* Create a block where the return registers can be saved.  */
1547   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1548
1549   /* Fetch the arg pointer from the ARGUMENTS block.  */
1550   incoming_args = gen_reg_rtx (Pmode);
1551   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1552 #ifndef STACK_GROWS_DOWNWARD
1553   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1554                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1555 #endif
1556
1557   /* Push a new argument block and copy the arguments.  Do not allow
1558      the (potential) memcpy call below to interfere with our stack
1559      manipulations.  */
1560   do_pending_stack_adjust ();
1561   NO_DEFER_POP;
1562
1563   /* Save the stack with nonlocal if available.  */
1564 #ifdef HAVE_save_stack_nonlocal
1565   if (HAVE_save_stack_nonlocal)
1566     emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1567   else
1568 #endif
1569     emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1570
1571   /* Allocate a block of memory onto the stack and copy the memory
1572      arguments to the outgoing arguments address.  We can pass TRUE
1573      as the 4th argument because we just saved the stack pointer
1574      and will restore it right after the call.  */
1575   allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT, TRUE);
1576
1577   /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1578      may have already set current_function_calls_alloca to true.
1579      current_function_calls_alloca won't be set if argsize is zero,
1580      so we have to guarantee need_drap is true here.  */
1581   if (SUPPORTS_STACK_ALIGNMENT)
1582     crtl->need_drap = true;
1583
1584   dest = virtual_outgoing_args_rtx;
1585 #ifndef STACK_GROWS_DOWNWARD
1586   if (CONST_INT_P (argsize))
1587     dest = plus_constant (dest, -INTVAL (argsize));
1588   else
1589     dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1590 #endif
1591   dest = gen_rtx_MEM (BLKmode, dest);
1592   set_mem_align (dest, PARM_BOUNDARY);
1593   src = gen_rtx_MEM (BLKmode, incoming_args);
1594   set_mem_align (src, PARM_BOUNDARY);
1595   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1596
1597   /* Refer to the argument block.  */
1598   apply_args_size ();
1599   arguments = gen_rtx_MEM (BLKmode, arguments);
1600   set_mem_align (arguments, PARM_BOUNDARY);
1601
1602   /* Walk past the arg-pointer and structure value address.  */
1603   size = GET_MODE_SIZE (Pmode);
1604   if (struct_value)
1605     size += GET_MODE_SIZE (Pmode);
1606
1607   /* Restore each of the registers previously saved.  Make USE insns
1608      for each of these registers for use in making the call.  */
1609   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1610     if ((mode = apply_args_mode[regno]) != VOIDmode)
1611       {
1612         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1613         if (size % align != 0)
1614           size = CEIL (size, align) * align;
1615         reg = gen_rtx_REG (mode, regno);
1616         emit_move_insn (reg, adjust_address (arguments, mode, size));
1617         use_reg (&call_fusage, reg);
1618         size += GET_MODE_SIZE (mode);
1619       }
1620
1621   /* Restore the structure value address unless this is passed as an
1622      "invisible" first argument.  */
1623   size = GET_MODE_SIZE (Pmode);
1624   if (struct_value)
1625     {
1626       rtx value = gen_reg_rtx (Pmode);
1627       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1628       emit_move_insn (struct_value, value);
1629       if (REG_P (struct_value))
1630         use_reg (&call_fusage, struct_value);
1631       size += GET_MODE_SIZE (Pmode);
1632     }
1633
1634   /* All arguments and registers used for the call are set up by now!  */
1635   function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1636
1637   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1638      and we don't want to load it into a register as an optimization,
1639      because prepare_call_address already did it if it should be done.  */
1640   if (GET_CODE (function) != SYMBOL_REF)
1641     function = memory_address (FUNCTION_MODE, function);
1642
1643   /* Generate the actual call instruction and save the return value.  */
1644 #ifdef HAVE_untyped_call
1645   if (HAVE_untyped_call)
1646     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1647                                       result, result_vector (1, result)));
1648   else
1649 #endif
1650 #ifdef HAVE_call_value
1651   if (HAVE_call_value)
1652     {
1653       rtx valreg = 0;
1654
1655       /* Locate the unique return register.  It is not possible to
1656          express a call that sets more than one return register using
1657          call_value; use untyped_call for that.  In fact, untyped_call
1658          only needs to save the return registers in the given block.  */
1659       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1660         if ((mode = apply_result_mode[regno]) != VOIDmode)
1661           {
1662             gcc_assert (!valreg); /* HAVE_untyped_call required.  */
1663
1664             valreg = gen_rtx_REG (mode, regno);
1665           }
1666
1667       emit_call_insn (GEN_CALL_VALUE (valreg,
1668                                       gen_rtx_MEM (FUNCTION_MODE, function),
1669                                       const0_rtx, NULL_RTX, const0_rtx));
1670
1671       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1672     }
1673   else
1674 #endif
1675     gcc_unreachable ();
1676
1677   /* Find the CALL insn we just emitted, and attach the register usage
1678      information.  */
1679   call_insn = last_call_insn ();
1680   add_function_usage_to (call_insn, call_fusage);
1681
1682   /* Restore the stack.  */
1683 #ifdef HAVE_save_stack_nonlocal
1684   if (HAVE_save_stack_nonlocal)
1685     emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1686   else
1687 #endif
1688     emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1689
1690   OK_DEFER_POP;
1691
1692   /* Return the address of the result block.  */
1693   result = copy_addr_to_reg (XEXP (result, 0));
1694   return convert_memory_address (ptr_mode, result);
1695 }
1696
1697 /* Perform an untyped return.  */
1698
1699 static void
1700 expand_builtin_return (rtx result)
1701 {
1702   int size, align, regno;
1703   enum machine_mode mode;
1704   rtx reg;
1705   rtx call_fusage = 0;
1706
1707   result = convert_memory_address (Pmode, result);
1708
1709   apply_result_size ();
1710   result = gen_rtx_MEM (BLKmode, result);
1711
1712 #ifdef HAVE_untyped_return
1713   if (HAVE_untyped_return)
1714     {
1715       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1716       emit_barrier ();
1717       return;
1718     }
1719 #endif
1720
1721   /* Restore the return value and note that each value is used.  */
1722   size = 0;
1723   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1724     if ((mode = apply_result_mode[regno]) != VOIDmode)
1725       {
1726         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1727         if (size % align != 0)
1728           size = CEIL (size, align) * align;
1729         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1730         emit_move_insn (reg, adjust_address (result, mode, size));
1731
1732         push_to_sequence (call_fusage);
1733         emit_use (reg);
1734         call_fusage = get_insns ();
1735         end_sequence ();
1736         size += GET_MODE_SIZE (mode);
1737       }
1738
1739   /* Put the USE insns before the return.  */
1740   emit_insn (call_fusage);
1741
1742   /* Return whatever values was restored by jumping directly to the end
1743      of the function.  */
1744   expand_naked_return ();
1745 }
1746
1747 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1748
1749 static enum type_class
1750 type_to_class (tree type)
1751 {
1752   switch (TREE_CODE (type))
1753     {
1754     case VOID_TYPE:        return void_type_class;
1755     case INTEGER_TYPE:     return integer_type_class;
1756     case ENUMERAL_TYPE:    return enumeral_type_class;
1757     case BOOLEAN_TYPE:     return boolean_type_class;
1758     case POINTER_TYPE:     return pointer_type_class;
1759     case REFERENCE_TYPE:   return reference_type_class;
1760     case OFFSET_TYPE:      return offset_type_class;
1761     case REAL_TYPE:        return real_type_class;
1762     case COMPLEX_TYPE:     return complex_type_class;
1763     case FUNCTION_TYPE:    return function_type_class;
1764     case METHOD_TYPE:      return method_type_class;
1765     case RECORD_TYPE:      return record_type_class;
1766     case UNION_TYPE:
1767     case QUAL_UNION_TYPE:  return union_type_class;
1768     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1769                                    ? string_type_class : array_type_class);
1770     case LANG_TYPE:        return lang_type_class;
1771     default:               return no_type_class;
1772     }
1773 }
1774
1775 /* Expand a call EXP to __builtin_classify_type.  */
1776
1777 static rtx
1778 expand_builtin_classify_type (tree exp)
1779 {
1780   if (call_expr_nargs (exp))
1781     return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1782   return GEN_INT (no_type_class);
1783 }
1784
1785 /* This helper macro, meant to be used in mathfn_built_in below,
1786    determines which among a set of three builtin math functions is
1787    appropriate for a given type mode.  The `F' and `L' cases are
1788    automatically generated from the `double' case.  */
1789 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1790   case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1791   fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1792   fcodel = BUILT_IN_MATHFN##L ; break;
1793 /* Similar to above, but appends _R after any F/L suffix.  */
1794 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1795   case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1796   fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1797   fcodel = BUILT_IN_MATHFN##L_R ; break;
1798
1799 /* Return mathematic function equivalent to FN but operating directly
1800    on TYPE, if available.  If IMPLICIT is true find the function in
1801    implicit_built_in_decls[], otherwise use built_in_decls[].  If we
1802    can't do the conversion, return zero.  */
1803
1804 static tree
1805 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit)
1806 {
1807   tree const *const fn_arr
1808     = implicit ? implicit_built_in_decls : built_in_decls;
1809   enum built_in_function fcode, fcodef, fcodel;
1810
1811   switch (fn)
1812     {
1813       CASE_MATHFN (BUILT_IN_ACOS)
1814       CASE_MATHFN (BUILT_IN_ACOSH)
1815       CASE_MATHFN (BUILT_IN_ASIN)
1816       CASE_MATHFN (BUILT_IN_ASINH)
1817       CASE_MATHFN (BUILT_IN_ATAN)
1818       CASE_MATHFN (BUILT_IN_ATAN2)
1819       CASE_MATHFN (BUILT_IN_ATANH)
1820       CASE_MATHFN (BUILT_IN_CBRT)
1821       CASE_MATHFN (BUILT_IN_CEIL)
1822       CASE_MATHFN (BUILT_IN_CEXPI)
1823       CASE_MATHFN (BUILT_IN_COPYSIGN)
1824       CASE_MATHFN (BUILT_IN_COS)
1825       CASE_MATHFN (BUILT_IN_COSH)
1826       CASE_MATHFN (BUILT_IN_DREM)
1827       CASE_MATHFN (BUILT_IN_ERF)
1828       CASE_MATHFN (BUILT_IN_ERFC)
1829       CASE_MATHFN (BUILT_IN_EXP)
1830       CASE_MATHFN (BUILT_IN_EXP10)
1831       CASE_MATHFN (BUILT_IN_EXP2)
1832       CASE_MATHFN (BUILT_IN_EXPM1)
1833       CASE_MATHFN (BUILT_IN_FABS)
1834       CASE_MATHFN (BUILT_IN_FDIM)
1835       CASE_MATHFN (BUILT_IN_FLOOR)
1836       CASE_MATHFN (BUILT_IN_FMA)
1837       CASE_MATHFN (BUILT_IN_FMAX)
1838       CASE_MATHFN (BUILT_IN_FMIN)
1839       CASE_MATHFN (BUILT_IN_FMOD)
1840       CASE_MATHFN (BUILT_IN_FREXP)
1841       CASE_MATHFN (BUILT_IN_GAMMA)
1842       CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1843       CASE_MATHFN (BUILT_IN_HUGE_VAL)
1844       CASE_MATHFN (BUILT_IN_HYPOT)
1845       CASE_MATHFN (BUILT_IN_ILOGB)
1846       CASE_MATHFN (BUILT_IN_INF)
1847       CASE_MATHFN (BUILT_IN_ISINF)
1848       CASE_MATHFN (BUILT_IN_J0)
1849       CASE_MATHFN (BUILT_IN_J1)
1850       CASE_MATHFN (BUILT_IN_JN)
1851       CASE_MATHFN (BUILT_IN_LCEIL)
1852       CASE_MATHFN (BUILT_IN_LDEXP)
1853       CASE_MATHFN (BUILT_IN_LFLOOR)
1854       CASE_MATHFN (BUILT_IN_LGAMMA)
1855       CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1856       CASE_MATHFN (BUILT_IN_LLCEIL)
1857       CASE_MATHFN (BUILT_IN_LLFLOOR)
1858       CASE_MATHFN (BUILT_IN_LLRINT)
1859       CASE_MATHFN (BUILT_IN_LLROUND)
1860       CASE_MATHFN (BUILT_IN_LOG)
1861       CASE_MATHFN (BUILT_IN_LOG10)
1862       CASE_MATHFN (BUILT_IN_LOG1P)
1863       CASE_MATHFN (BUILT_IN_LOG2)
1864       CASE_MATHFN (BUILT_IN_LOGB)
1865       CASE_MATHFN (BUILT_IN_LRINT)
1866       CASE_MATHFN (BUILT_IN_LROUND)
1867       CASE_MATHFN (BUILT_IN_MODF)
1868       CASE_MATHFN (BUILT_IN_NAN)
1869       CASE_MATHFN (BUILT_IN_NANS)
1870       CASE_MATHFN (BUILT_IN_NEARBYINT)
1871       CASE_MATHFN (BUILT_IN_NEXTAFTER)
1872       CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1873       CASE_MATHFN (BUILT_IN_POW)
1874       CASE_MATHFN (BUILT_IN_POWI)
1875       CASE_MATHFN (BUILT_IN_POW10)
1876       CASE_MATHFN (BUILT_IN_REMAINDER)
1877       CASE_MATHFN (BUILT_IN_REMQUO)
1878       CASE_MATHFN (BUILT_IN_RINT)
1879       CASE_MATHFN (BUILT_IN_ROUND)
1880       CASE_MATHFN (BUILT_IN_SCALB)
1881       CASE_MATHFN (BUILT_IN_SCALBLN)
1882       CASE_MATHFN (BUILT_IN_SCALBN)
1883       CASE_MATHFN (BUILT_IN_SIGNBIT)
1884       CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1885       CASE_MATHFN (BUILT_IN_SIN)
1886       CASE_MATHFN (BUILT_IN_SINCOS)
1887       CASE_MATHFN (BUILT_IN_SINH)
1888       CASE_MATHFN (BUILT_IN_SQRT)
1889       CASE_MATHFN (BUILT_IN_TAN)
1890       CASE_MATHFN (BUILT_IN_TANH)
1891       CASE_MATHFN (BUILT_IN_TGAMMA)
1892       CASE_MATHFN (BUILT_IN_TRUNC)
1893       CASE_MATHFN (BUILT_IN_Y0)
1894       CASE_MATHFN (BUILT_IN_Y1)
1895       CASE_MATHFN (BUILT_IN_YN)
1896
1897       default:
1898         return NULL_TREE;
1899       }
1900
1901   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1902     return fn_arr[fcode];
1903   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1904     return fn_arr[fcodef];
1905   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1906     return fn_arr[fcodel];
1907   else
1908     return NULL_TREE;
1909 }
1910
1911 /* Like mathfn_built_in_1(), but always use the implicit array.  */
1912
1913 tree
1914 mathfn_built_in (tree type, enum built_in_function fn)
1915 {
1916   return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1917 }
1918
1919 /* If errno must be maintained, expand the RTL to check if the result,
1920    TARGET, of a built-in function call, EXP, is NaN, and if so set
1921    errno to EDOM.  */
1922
1923 static void
1924 expand_errno_check (tree exp, rtx target)
1925 {
1926   rtx lab = gen_label_rtx ();
1927
1928   /* Test the result; if it is NaN, set errno=EDOM because
1929      the argument was not in the domain.  */
1930   do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1931                            NULL_RTX, NULL_RTX, lab,
1932                            /* The jump is very likely.  */
1933                            REG_BR_PROB_BASE - (REG_BR_PROB_BASE / 2000 - 1));
1934
1935 #ifdef TARGET_EDOM
1936   /* If this built-in doesn't throw an exception, set errno directly.  */
1937   if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1938     {
1939 #ifdef GEN_ERRNO_RTX
1940       rtx errno_rtx = GEN_ERRNO_RTX;
1941 #else
1942       rtx errno_rtx
1943           = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1944 #endif
1945       emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1946       emit_label (lab);
1947       return;
1948     }
1949 #endif
1950
1951   /* Make sure the library call isn't expanded as a tail call.  */
1952   CALL_EXPR_TAILCALL (exp) = 0;
1953
1954   /* We can't set errno=EDOM directly; let the library call do it.
1955      Pop the arguments right away in case the call gets deleted.  */
1956   NO_DEFER_POP;
1957   expand_call (exp, target, 0);
1958   OK_DEFER_POP;
1959   emit_label (lab);
1960 }
1961
1962 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1963    Return NULL_RTX if a normal call should be emitted rather than expanding
1964    the function in-line.  EXP is the expression that is a call to the builtin
1965    function; if convenient, the result should be placed in TARGET.
1966    SUBTARGET may be used as the target for computing one of EXP's operands.  */
1967
1968 static rtx
1969 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1970 {
1971   optab builtin_optab;
1972   rtx op0, insns;
1973   tree fndecl = get_callee_fndecl (exp);
1974   enum machine_mode mode;
1975   bool errno_set = false;
1976   tree arg;
1977
1978   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1979     return NULL_RTX;
1980
1981   arg = CALL_EXPR_ARG (exp, 0);
1982
1983   switch (DECL_FUNCTION_CODE (fndecl))
1984     {
1985     CASE_FLT_FN (BUILT_IN_SQRT):
1986       errno_set = ! tree_expr_nonnegative_p (arg);
1987       builtin_optab = sqrt_optab;
1988       break;
1989     CASE_FLT_FN (BUILT_IN_EXP):
1990       errno_set = true; builtin_optab = exp_optab; break;
1991     CASE_FLT_FN (BUILT_IN_EXP10):
1992     CASE_FLT_FN (BUILT_IN_POW10):
1993       errno_set = true; builtin_optab = exp10_optab; break;
1994     CASE_FLT_FN (BUILT_IN_EXP2):
1995       errno_set = true; builtin_optab = exp2_optab; break;
1996     CASE_FLT_FN (BUILT_IN_EXPM1):
1997       errno_set = true; builtin_optab = expm1_optab; break;
1998     CASE_FLT_FN (BUILT_IN_LOGB):
1999       errno_set = true; builtin_optab = logb_optab; break;
2000     CASE_FLT_FN (BUILT_IN_LOG):
2001       errno_set = true; builtin_optab = log_optab; break;
2002     CASE_FLT_FN (BUILT_IN_LOG10):
2003       errno_set = true; builtin_optab = log10_optab; break;
2004     CASE_FLT_FN (BUILT_IN_LOG2):
2005       errno_set = true; builtin_optab = log2_optab; break;
2006     CASE_FLT_FN (BUILT_IN_LOG1P):
2007       errno_set = true; builtin_optab = log1p_optab; break;
2008     CASE_FLT_FN (BUILT_IN_ASIN):
2009       builtin_optab = asin_optab; break;
2010     CASE_FLT_FN (BUILT_IN_ACOS):
2011       builtin_optab = acos_optab; break;
2012     CASE_FLT_FN (BUILT_IN_TAN):
2013       builtin_optab = tan_optab; break;
2014     CASE_FLT_FN (BUILT_IN_ATAN):
2015       builtin_optab = atan_optab; break;
2016     CASE_FLT_FN (BUILT_IN_FLOOR):
2017       builtin_optab = floor_optab; break;
2018     CASE_FLT_FN (BUILT_IN_CEIL):
2019       builtin_optab = ceil_optab; break;
2020     CASE_FLT_FN (BUILT_IN_TRUNC):
2021       builtin_optab = btrunc_optab; break;
2022     CASE_FLT_FN (BUILT_IN_ROUND):
2023       builtin_optab = round_optab; break;
2024     CASE_FLT_FN (BUILT_IN_NEARBYINT):
2025       builtin_optab = nearbyint_optab;
2026       if (flag_trapping_math)
2027         break;
2028       /* Else fallthrough and expand as rint.  */
2029     CASE_FLT_FN (BUILT_IN_RINT):
2030       builtin_optab = rint_optab; break;
2031     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
2032       builtin_optab = significand_optab; break;
2033     default:
2034       gcc_unreachable ();
2035     }
2036
2037   /* Make a suitable register to place result in.  */
2038   mode = TYPE_MODE (TREE_TYPE (exp));
2039
2040   if (! flag_errno_math || ! HONOR_NANS (mode))
2041     errno_set = false;
2042
2043   /* Before working hard, check whether the instruction is available.  */
2044   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2045     {
2046       target = gen_reg_rtx (mode);
2047
2048       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2049          need to expand the argument again.  This way, we will not perform
2050          side-effects more the once.  */
2051       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2052
2053       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2054
2055       start_sequence ();
2056
2057       /* Compute into TARGET.
2058          Set TARGET to wherever the result comes back.  */
2059       target = expand_unop (mode, builtin_optab, op0, target, 0);
2060
2061       if (target != 0)
2062         {
2063           if (errno_set)
2064             expand_errno_check (exp, target);
2065
2066           /* Output the entire sequence.  */
2067           insns = get_insns ();
2068           end_sequence ();
2069           emit_insn (insns);
2070           return target;
2071         }
2072
2073       /* If we were unable to expand via the builtin, stop the sequence
2074          (without outputting the insns) and call to the library function
2075          with the stabilized argument list.  */
2076       end_sequence ();
2077     }
2078
2079   return expand_call (exp, target, target == const0_rtx);
2080 }
2081
2082 /* Expand a call to the builtin binary math functions (pow and atan2).
2083    Return NULL_RTX if a normal call should be emitted rather than expanding the
2084    function in-line.  EXP is the expression that is a call to the builtin
2085    function; if convenient, the result should be placed in TARGET.
2086    SUBTARGET may be used as the target for computing one of EXP's
2087    operands.  */
2088
2089 static rtx
2090 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2091 {
2092   optab builtin_optab;
2093   rtx op0, op1, insns;
2094   int op1_type = REAL_TYPE;
2095   tree fndecl = get_callee_fndecl (exp);
2096   tree arg0, arg1;
2097   enum machine_mode mode;
2098   bool errno_set = true;
2099
2100   switch (DECL_FUNCTION_CODE (fndecl))
2101     {
2102     CASE_FLT_FN (BUILT_IN_SCALBN):
2103     CASE_FLT_FN (BUILT_IN_SCALBLN):
2104     CASE_FLT_FN (BUILT_IN_LDEXP):
2105       op1_type = INTEGER_TYPE;
2106     default:
2107       break;
2108     }
2109
2110   if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2111     return NULL_RTX;
2112
2113   arg0 = CALL_EXPR_ARG (exp, 0);
2114   arg1 = CALL_EXPR_ARG (exp, 1);
2115
2116   switch (DECL_FUNCTION_CODE (fndecl))
2117     {
2118     CASE_FLT_FN (BUILT_IN_POW):
2119       builtin_optab = pow_optab; break;
2120     CASE_FLT_FN (BUILT_IN_ATAN2):
2121       builtin_optab = atan2_optab; break;
2122     CASE_FLT_FN (BUILT_IN_SCALB):
2123       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2124         return 0;
2125       builtin_optab = scalb_optab; break;
2126     CASE_FLT_FN (BUILT_IN_SCALBN):
2127     CASE_FLT_FN (BUILT_IN_SCALBLN):
2128       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2129         return 0;
2130     /* Fall through... */
2131     CASE_FLT_FN (BUILT_IN_LDEXP):
2132       builtin_optab = ldexp_optab; break;
2133     CASE_FLT_FN (BUILT_IN_FMOD):
2134       builtin_optab = fmod_optab; break;
2135     CASE_FLT_FN (BUILT_IN_REMAINDER):
2136     CASE_FLT_FN (BUILT_IN_DREM):
2137       builtin_optab = remainder_optab; break;
2138     default:
2139       gcc_unreachable ();
2140     }
2141
2142   /* Make a suitable register to place result in.  */
2143   mode = TYPE_MODE (TREE_TYPE (exp));
2144
2145   /* Before working hard, check whether the instruction is available.  */
2146   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2147     return NULL_RTX;
2148
2149   target = gen_reg_rtx (mode);
2150
2151   if (! flag_errno_math || ! HONOR_NANS (mode))
2152     errno_set = false;
2153
2154   /* Always stabilize the argument list.  */
2155   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2156   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2157
2158   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2159   op1 = expand_normal (arg1);
2160
2161   start_sequence ();
2162
2163   /* Compute into TARGET.
2164      Set TARGET to wherever the result comes back.  */
2165   target = expand_binop (mode, builtin_optab, op0, op1,
2166                          target, 0, OPTAB_DIRECT);
2167
2168   /* If we were unable to expand via the builtin, stop the sequence
2169      (without outputting the insns) and call to the library function
2170      with the stabilized argument list.  */
2171   if (target == 0)
2172     {
2173       end_sequence ();
2174       return expand_call (exp, target, target == const0_rtx);
2175     }
2176
2177   if (errno_set)
2178     expand_errno_check (exp, target);
2179
2180   /* Output the entire sequence.  */
2181   insns = get_insns ();
2182   end_sequence ();
2183   emit_insn (insns);
2184
2185   return target;
2186 }
2187
2188 /* Expand a call to the builtin sin and cos math functions.
2189    Return NULL_RTX if a normal call should be emitted rather than expanding the
2190    function in-line.  EXP is the expression that is a call to the builtin
2191    function; if convenient, the result should be placed in TARGET.
2192    SUBTARGET may be used as the target for computing one of EXP's
2193    operands.  */
2194
2195 static rtx
2196 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2197 {
2198   optab builtin_optab;
2199   rtx op0, insns;
2200   tree fndecl = get_callee_fndecl (exp);
2201   enum machine_mode mode;
2202   tree arg;
2203
2204   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2205     return NULL_RTX;
2206
2207   arg = CALL_EXPR_ARG (exp, 0);
2208
2209   switch (DECL_FUNCTION_CODE (fndecl))
2210     {
2211     CASE_FLT_FN (BUILT_IN_SIN):
2212     CASE_FLT_FN (BUILT_IN_COS):
2213       builtin_optab = sincos_optab; break;
2214     default:
2215       gcc_unreachable ();
2216     }
2217
2218   /* Make a suitable register to place result in.  */
2219   mode = TYPE_MODE (TREE_TYPE (exp));
2220
2221   /* Check if sincos insn is available, otherwise fallback
2222      to sin or cos insn.  */
2223   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2224     switch (DECL_FUNCTION_CODE (fndecl))
2225       {
2226       CASE_FLT_FN (BUILT_IN_SIN):
2227         builtin_optab = sin_optab; break;
2228       CASE_FLT_FN (BUILT_IN_COS):
2229         builtin_optab = cos_optab; break;
2230       default:
2231         gcc_unreachable ();
2232       }
2233
2234   /* Before working hard, check whether the instruction is available.  */
2235   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2236     {
2237       target = gen_reg_rtx (mode);
2238
2239       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2240          need to expand the argument again.  This way, we will not perform
2241          side-effects more the once.  */
2242       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2243
2244       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2245
2246       start_sequence ();
2247
2248       /* Compute into TARGET.
2249          Set TARGET to wherever the result comes back.  */
2250       if (builtin_optab == sincos_optab)
2251         {
2252           int result;
2253
2254           switch (DECL_FUNCTION_CODE (fndecl))
2255             {
2256             CASE_FLT_FN (BUILT_IN_SIN):
2257               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2258               break;
2259             CASE_FLT_FN (BUILT_IN_COS):
2260               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2261               break;
2262             default:
2263               gcc_unreachable ();
2264             }
2265           gcc_assert (result);
2266         }
2267       else
2268         {
2269           target = expand_unop (mode, builtin_optab, op0, target, 0);
2270         }
2271
2272       if (target != 0)
2273         {
2274           /* Output the entire sequence.  */
2275           insns = get_insns ();
2276           end_sequence ();
2277           emit_insn (insns);
2278           return target;
2279         }
2280
2281       /* If we were unable to expand via the builtin, stop the sequence
2282          (without outputting the insns) and call to the library function
2283          with the stabilized argument list.  */
2284       end_sequence ();
2285     }
2286
2287   target = expand_call (exp, target, target == const0_rtx);
2288
2289   return target;
2290 }
2291
2292 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2293    return an RTL instruction code that implements the functionality.
2294    If that isn't possible or available return CODE_FOR_nothing.  */
2295
2296 static enum insn_code
2297 interclass_mathfn_icode (tree arg, tree fndecl)
2298 {
2299   bool errno_set = false;
2300   optab builtin_optab = 0;
2301   enum machine_mode mode;
2302
2303   switch (DECL_FUNCTION_CODE (fndecl))
2304     {
2305     CASE_FLT_FN (BUILT_IN_ILOGB):
2306       errno_set = true; builtin_optab = ilogb_optab; break;
2307     CASE_FLT_FN (BUILT_IN_ISINF):
2308       builtin_optab = isinf_optab; break;
2309     case BUILT_IN_ISNORMAL:
2310     case BUILT_IN_ISFINITE:
2311     CASE_FLT_FN (BUILT_IN_FINITE):
2312     case BUILT_IN_FINITED32:
2313     case BUILT_IN_FINITED64:
2314     case BUILT_IN_FINITED128:
2315     case BUILT_IN_ISINFD32:
2316     case BUILT_IN_ISINFD64:
2317     case BUILT_IN_ISINFD128:
2318       /* These builtins have no optabs (yet).  */
2319       break;
2320     default:
2321       gcc_unreachable ();
2322     }
2323
2324   /* There's no easy way to detect the case we need to set EDOM.  */
2325   if (flag_errno_math && errno_set)
2326     return CODE_FOR_nothing;
2327
2328   /* Optab mode depends on the mode of the input argument.  */
2329   mode = TYPE_MODE (TREE_TYPE (arg));
2330
2331   if (builtin_optab)
2332     return optab_handler (builtin_optab, mode);
2333   return CODE_FOR_nothing;
2334 }
2335
2336 /* Expand a call to one of the builtin math functions that operate on
2337    floating point argument and output an integer result (ilogb, isinf,
2338    isnan, etc).
2339    Return 0 if a normal call should be emitted rather than expanding the
2340    function in-line.  EXP is the expression that is a call to the builtin
2341    function; if convenient, the result should be placed in TARGET.  */
2342
2343 static rtx
2344 expand_builtin_interclass_mathfn (tree exp, rtx target)
2345 {
2346   enum insn_code icode = CODE_FOR_nothing;
2347   rtx op0;
2348   tree fndecl = get_callee_fndecl (exp);
2349   enum machine_mode mode;
2350   tree arg;
2351
2352   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2353     return NULL_RTX;
2354
2355   arg = CALL_EXPR_ARG (exp, 0);
2356   icode = interclass_mathfn_icode (arg, fndecl);
2357   mode = TYPE_MODE (TREE_TYPE (arg));
2358
2359   if (icode != CODE_FOR_nothing)
2360     {
2361       rtx last = get_last_insn ();
2362       tree orig_arg = arg;
2363       /* Make a suitable register to place result in.  */
2364       if (!target
2365           || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp))
2366           || !insn_data[icode].operand[0].predicate (target, GET_MODE (target)))
2367          target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2368
2369       gcc_assert (insn_data[icode].operand[0].predicate
2370                   (target, GET_MODE (target)));
2371
2372       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2373          need to expand the argument again.  This way, we will not perform
2374          side-effects more the once.  */
2375       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2376
2377       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2378
2379       if (mode != GET_MODE (op0))
2380         op0 = convert_to_mode (mode, op0, 0);
2381
2382       /* Compute into TARGET.
2383          Set TARGET to wherever the result comes back.  */
2384       if (maybe_emit_unop_insn (icode, target, op0, UNKNOWN))
2385         return target;
2386       delete_insns_since (last);
2387       CALL_EXPR_ARG (exp, 0) = orig_arg;
2388     }
2389
2390   return NULL_RTX;
2391 }
2392
2393 /* Expand a call to the builtin sincos math function.
2394    Return NULL_RTX if a normal call should be emitted rather than expanding the
2395    function in-line.  EXP is the expression that is a call to the builtin
2396    function.  */
2397
2398 static rtx
2399 expand_builtin_sincos (tree exp)
2400 {
2401   rtx op0, op1, op2, target1, target2;
2402   enum machine_mode mode;
2403   tree arg, sinp, cosp;
2404   int result;
2405   location_t loc = EXPR_LOCATION (exp);
2406
2407   if (!validate_arglist (exp, REAL_TYPE,
2408                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2409     return NULL_RTX;
2410
2411   arg = CALL_EXPR_ARG (exp, 0);
2412   sinp = CALL_EXPR_ARG (exp, 1);
2413   cosp = CALL_EXPR_ARG (exp, 2);
2414
2415   /* Make a suitable register to place result in.  */
2416   mode = TYPE_MODE (TREE_TYPE (arg));
2417
2418   /* Check if sincos insn is available, otherwise emit the call.  */
2419   if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2420     return NULL_RTX;
2421
2422   target1 = gen_reg_rtx (mode);
2423   target2 = gen_reg_rtx (mode);
2424
2425   op0 = expand_normal (arg);
2426   op1 = expand_normal (build_fold_indirect_ref_loc (loc, sinp));
2427   op2 = expand_normal (build_fold_indirect_ref_loc (loc, cosp));
2428
2429   /* Compute into target1 and target2.
2430      Set TARGET to wherever the result comes back.  */
2431   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2432   gcc_assert (result);
2433
2434   /* Move target1 and target2 to the memory locations indicated
2435      by op1 and op2.  */
2436   emit_move_insn (op1, target1);
2437   emit_move_insn (op2, target2);
2438
2439   return const0_rtx;
2440 }
2441
2442 /* Expand a call to the internal cexpi builtin to the sincos math function.
2443    EXP is the expression that is a call to the builtin function; if convenient,
2444    the result should be placed in TARGET.  */
2445
2446 static rtx
2447 expand_builtin_cexpi (tree exp, rtx target)
2448 {
2449   tree fndecl = get_callee_fndecl (exp);
2450   tree arg, type;
2451   enum machine_mode mode;
2452   rtx op0, op1, op2;
2453   location_t loc = EXPR_LOCATION (exp);
2454
2455   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2456     return NULL_RTX;
2457
2458   arg = CALL_EXPR_ARG (exp, 0);
2459   type = TREE_TYPE (arg);
2460   mode = TYPE_MODE (TREE_TYPE (arg));
2461
2462   /* Try expanding via a sincos optab, fall back to emitting a libcall
2463      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2464      is only generated from sincos, cexp or if we have either of them.  */
2465   if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2466     {
2467       op1 = gen_reg_rtx (mode);
2468       op2 = gen_reg_rtx (mode);
2469
2470       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2471
2472       /* Compute into op1 and op2.  */
2473       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2474     }
2475   else if (TARGET_HAS_SINCOS)
2476     {
2477       tree call, fn = NULL_TREE;
2478       tree top1, top2;
2479       rtx op1a, op2a;
2480
2481       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2482         fn = built_in_decls[BUILT_IN_SINCOSF];
2483       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2484         fn = built_in_decls[BUILT_IN_SINCOS];
2485       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2486         fn = built_in_decls[BUILT_IN_SINCOSL];
2487       else
2488         gcc_unreachable ();
2489
2490       op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2491       op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2492       op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2493       op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2494       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2495       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2496
2497       /* Make sure not to fold the sincos call again.  */
2498       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2499       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2500                                       call, 3, arg, top1, top2));
2501     }
2502   else
2503     {
2504       tree call, fn = NULL_TREE, narg;
2505       tree ctype = build_complex_type (type);
2506
2507       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2508         fn = built_in_decls[BUILT_IN_CEXPF];
2509       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2510         fn = built_in_decls[BUILT_IN_CEXP];
2511       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2512         fn = built_in_decls[BUILT_IN_CEXPL];
2513       else
2514         gcc_unreachable ();
2515
2516       /* If we don't have a decl for cexp create one.  This is the
2517          friendliest fallback if the user calls __builtin_cexpi
2518          without full target C99 function support.  */
2519       if (fn == NULL_TREE)
2520         {
2521           tree fntype;
2522           const char *name = NULL;
2523
2524           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2525             name = "cexpf";
2526           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2527             name = "cexp";
2528           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2529             name = "cexpl";
2530
2531           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2532           fn = build_fn_decl (name, fntype);
2533         }
2534
2535       narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2536                           build_real (type, dconst0), arg);
2537
2538       /* Make sure not to fold the cexp call again.  */
2539       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2540       return expand_expr (build_call_nary (ctype, call, 1, narg),
2541                           target, VOIDmode, EXPAND_NORMAL);
2542     }
2543
2544   /* Now build the proper return type.  */
2545   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2546                               make_tree (TREE_TYPE (arg), op2),
2547                               make_tree (TREE_TYPE (arg), op1)),
2548                       target, VOIDmode, EXPAND_NORMAL);
2549 }
2550
2551 /* Conveniently construct a function call expression.  FNDECL names the
2552    function to be called, N is the number of arguments, and the "..."
2553    parameters are the argument expressions.  Unlike build_call_exr
2554    this doesn't fold the call, hence it will always return a CALL_EXPR.  */
2555
2556 static tree
2557 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2558 {
2559   va_list ap;
2560   tree fntype = TREE_TYPE (fndecl);
2561   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2562
2563   va_start (ap, n);
2564   fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2565   va_end (ap);
2566   SET_EXPR_LOCATION (fn, loc);
2567   return fn;
2568 }
2569
2570 /* Expand a call to one of the builtin rounding functions gcc defines
2571    as an extension (lfloor and lceil).  As these are gcc extensions we
2572    do not need to worry about setting errno to EDOM.
2573    If expanding via optab fails, lower expression to (int)(floor(x)).
2574    EXP is the expression that is a call to the builtin function;
2575    if convenient, the result should be placed in TARGET.  */
2576
2577 static rtx
2578 expand_builtin_int_roundingfn (tree exp, rtx target)
2579 {
2580   convert_optab builtin_optab;
2581   rtx op0, insns, tmp;
2582   tree fndecl = get_callee_fndecl (exp);
2583   enum built_in_function fallback_fn;
2584   tree fallback_fndecl;
2585   enum machine_mode mode;
2586   tree arg;
2587
2588   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2589     gcc_unreachable ();
2590
2591   arg = CALL_EXPR_ARG (exp, 0);
2592
2593   switch (DECL_FUNCTION_CODE (fndecl))
2594     {
2595     CASE_FLT_FN (BUILT_IN_LCEIL):
2596     CASE_FLT_FN (BUILT_IN_LLCEIL):
2597       builtin_optab = lceil_optab;
2598       fallback_fn = BUILT_IN_CEIL;
2599       break;
2600
2601     CASE_FLT_FN (BUILT_IN_LFLOOR):
2602     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2603       builtin_optab = lfloor_optab;
2604       fallback_fn = BUILT_IN_FLOOR;
2605       break;
2606
2607     default:
2608       gcc_unreachable ();
2609     }
2610
2611   /* Make a suitable register to place result in.  */
2612   mode = TYPE_MODE (TREE_TYPE (exp));
2613
2614   target = gen_reg_rtx (mode);
2615
2616   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2617      need to expand the argument again.  This way, we will not perform
2618      side-effects more the once.  */
2619   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2620
2621   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2622
2623   start_sequence ();
2624
2625   /* Compute into TARGET.  */
2626   if (expand_sfix_optab (target, op0, builtin_optab))
2627     {
2628       /* Output the entire sequence.  */
2629       insns = get_insns ();
2630       end_sequence ();
2631       emit_insn (insns);
2632       return target;
2633     }
2634
2635   /* If we were unable to expand via the builtin, stop the sequence
2636      (without outputting the insns).  */
2637   end_sequence ();
2638
2639   /* Fall back to floating point rounding optab.  */
2640   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2641
2642   /* For non-C99 targets we may end up without a fallback fndecl here
2643      if the user called __builtin_lfloor directly.  In this case emit
2644      a call to the floor/ceil variants nevertheless.  This should result
2645      in the best user experience for not full C99 targets.  */
2646   if (fallback_fndecl == NULL_TREE)
2647     {
2648       tree fntype;
2649       const char *name = NULL;
2650
2651       switch (DECL_FUNCTION_CODE (fndecl))
2652         {
2653         case BUILT_IN_LCEIL:
2654         case BUILT_IN_LLCEIL:
2655           name = "ceil";
2656           break;
2657         case BUILT_IN_LCEILF:
2658         case BUILT_IN_LLCEILF:
2659           name = "ceilf";
2660           break;
2661         case BUILT_IN_LCEILL:
2662         case BUILT_IN_LLCEILL:
2663           name = "ceill";
2664           break;
2665         case BUILT_IN_LFLOOR:
2666         case BUILT_IN_LLFLOOR:
2667           name = "floor";
2668           break;
2669         case BUILT_IN_LFLOORF:
2670         case BUILT_IN_LLFLOORF:
2671           name = "floorf";
2672           break;
2673         case BUILT_IN_LFLOORL:
2674         case BUILT_IN_LLFLOORL:
2675           name = "floorl";
2676           break;
2677         default:
2678           gcc_unreachable ();
2679         }
2680
2681       fntype = build_function_type_list (TREE_TYPE (arg),
2682                                          TREE_TYPE (arg), NULL_TREE);
2683       fallback_fndecl = build_fn_decl (name, fntype);
2684     }
2685
2686   exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2687
2688   tmp = expand_normal (exp);
2689
2690   /* Truncate the result of floating point optab to integer
2691      via expand_fix ().  */
2692   target = gen_reg_rtx (mode);
2693   expand_fix (target, tmp, 0);
2694
2695   return target;
2696 }
2697
2698 /* Expand a call to one of the builtin math functions doing integer
2699    conversion (lrint).
2700    Return 0 if a normal call should be emitted rather than expanding the
2701    function in-line.  EXP is the expression that is a call to the builtin
2702    function; if convenient, the result should be placed in TARGET.  */
2703
2704 static rtx
2705 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2706 {
2707   convert_optab builtin_optab;
2708   rtx op0, insns;
2709   tree fndecl = get_callee_fndecl (exp);
2710   tree arg;
2711   enum machine_mode mode;
2712
2713   /* There's no easy way to detect the case we need to set EDOM.  */
2714   if (flag_errno_math)
2715     return NULL_RTX;
2716
2717   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2718      gcc_unreachable ();
2719
2720   arg = CALL_EXPR_ARG (exp, 0);
2721
2722   switch (DECL_FUNCTION_CODE (fndecl))
2723     {
2724     CASE_FLT_FN (BUILT_IN_LRINT):
2725     CASE_FLT_FN (BUILT_IN_LLRINT):
2726       builtin_optab = lrint_optab; break;
2727     CASE_FLT_FN (BUILT_IN_LROUND):
2728     CASE_FLT_FN (BUILT_IN_LLROUND):
2729       builtin_optab = lround_optab; break;
2730     default:
2731       gcc_unreachable ();
2732     }
2733
2734   /* Make a suitable register to place result in.  */
2735   mode = TYPE_MODE (TREE_TYPE (exp));
2736
2737   target = gen_reg_rtx (mode);
2738
2739   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2740      need to expand the argument again.  This way, we will not perform
2741      side-effects more the once.  */
2742   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2743
2744   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2745
2746   start_sequence ();
2747
2748   if (expand_sfix_optab (target, op0, builtin_optab))
2749     {
2750       /* Output the entire sequence.  */
2751       insns = get_insns ();
2752       end_sequence ();
2753       emit_insn (insns);
2754       return target;
2755     }
2756
2757   /* If we were unable to expand via the builtin, stop the sequence
2758      (without outputting the insns) and call to the library function
2759      with the stabilized argument list.  */
2760   end_sequence ();
2761
2762   target = expand_call (exp, target, target == const0_rtx);
2763
2764   return target;
2765 }
2766
2767 /* To evaluate powi(x,n), the floating point value x raised to the
2768    constant integer exponent n, we use a hybrid algorithm that
2769    combines the "window method" with look-up tables.  For an
2770    introduction to exponentiation algorithms and "addition chains",
2771    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2772    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2773    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2774    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2775
2776 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2777    multiplications to inline before calling the system library's pow
2778    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2779    so this default never requires calling pow, powf or powl.  */
2780
2781 #ifndef POWI_MAX_MULTS
2782 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2783 #endif
2784
2785 /* The size of the "optimal power tree" lookup table.  All
2786    exponents less than this value are simply looked up in the
2787    powi_table below.  This threshold is also used to size the
2788    cache of pseudo registers that hold intermediate results.  */
2789 #define POWI_TABLE_SIZE 256
2790
2791 /* The size, in bits of the window, used in the "window method"
2792    exponentiation algorithm.  This is equivalent to a radix of
2793    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2794 #define POWI_WINDOW_SIZE 3
2795
2796 /* The following table is an efficient representation of an
2797    "optimal power tree".  For each value, i, the corresponding
2798    value, j, in the table states than an optimal evaluation
2799    sequence for calculating pow(x,i) can be found by evaluating
2800    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2801    100 integers is given in Knuth's "Seminumerical algorithms".  */
2802
2803 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2804   {
2805       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2806       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2807       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2808      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2809      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2810      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2811      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2812      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2813      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2814      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2815      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2816      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2817      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2818      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2819      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2820      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2821      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2822      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2823      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2824      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2825      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2826      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2827      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2828      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2829      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2830     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2831     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2832     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2833     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2834     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2835     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2836     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2837   };
2838
2839
2840 /* Return the number of multiplications required to calculate
2841    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2842    subroutine of powi_cost.  CACHE is an array indicating
2843    which exponents have already been calculated.  */
2844
2845 static int
2846 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2847 {
2848   /* If we've already calculated this exponent, then this evaluation
2849      doesn't require any additional multiplications.  */
2850   if (cache[n])
2851     return 0;
2852
2853   cache[n] = true;
2854   return powi_lookup_cost (n - powi_table[n], cache)
2855          + powi_lookup_cost (powi_table[n], cache) + 1;
2856 }
2857
2858 /* Return the number of multiplications required to calculate
2859    powi(x,n) for an arbitrary x, given the exponent N.  This
2860    function needs to be kept in sync with expand_powi below.  */
2861
2862 static int
2863 powi_cost (HOST_WIDE_INT n)
2864 {
2865   bool cache[POWI_TABLE_SIZE];
2866   unsigned HOST_WIDE_INT digit;
2867   unsigned HOST_WIDE_INT val;
2868   int result;
2869
2870   if (n == 0)
2871     return 0;
2872
2873   /* Ignore the reciprocal when calculating the cost.  */
2874   val = (n < 0) ? -n : n;
2875
2876   /* Initialize the exponent cache.  */
2877   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2878   cache[1] = true;
2879
2880   result = 0;
2881
2882   while (val >= POWI_TABLE_SIZE)
2883     {
2884       if (val & 1)
2885         {
2886           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2887           result += powi_lookup_cost (digit, cache)
2888                     + POWI_WINDOW_SIZE + 1;
2889           val >>= POWI_WINDOW_SIZE;
2890         }
2891       else
2892         {
2893           val >>= 1;
2894           result++;
2895         }
2896     }
2897
2898   return result + powi_lookup_cost (val, cache);
2899 }
2900
2901 /* Recursive subroutine of expand_powi.  This function takes the array,
2902    CACHE, of already calculated exponents and an exponent N and returns
2903    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2904
2905 static rtx
2906 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2907 {
2908   unsigned HOST_WIDE_INT digit;
2909   rtx target, result;
2910   rtx op0, op1;
2911
2912   if (n < POWI_TABLE_SIZE)
2913     {
2914       if (cache[n])
2915         return cache[n];
2916
2917       target = gen_reg_rtx (mode);
2918       cache[n] = target;
2919
2920       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2921       op1 = expand_powi_1 (mode, powi_table[n], cache);
2922     }
2923   else if (n & 1)
2924     {
2925       target = gen_reg_rtx (mode);
2926       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2927       op0 = expand_powi_1 (mode, n - digit, cache);
2928       op1 = expand_powi_1 (mode, digit, cache);
2929     }
2930   else
2931     {
2932       target = gen_reg_rtx (mode);
2933       op0 = expand_powi_1 (mode, n >> 1, cache);
2934       op1 = op0;
2935     }
2936
2937   result = expand_mult (mode, op0, op1, target, 0);
2938   if (result != target)
2939     emit_move_insn (target, result);
2940   return target;
2941 }
2942
2943 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
2944    floating point operand in mode MODE, and N is the exponent.  This
2945    function needs to be kept in sync with powi_cost above.  */
2946
2947 static rtx
2948 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2949 {
2950   rtx cache[POWI_TABLE_SIZE];
2951   rtx result;
2952
2953   if (n == 0)
2954     return CONST1_RTX (mode);
2955
2956   memset (cache, 0, sizeof (cache));
2957   cache[1] = x;
2958
2959   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2960
2961   /* If the original exponent was negative, reciprocate the result.  */
2962   if (n < 0)
2963     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2964                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2965
2966   return result;
2967 }
2968
2969 /* Fold a builtin function call to pow, powf, or powl into a series of sqrts or
2970    cbrts.  Return NULL_RTX if no simplification can be made or expand the tree
2971    if we can simplify it.  */
2972 static rtx
2973 expand_builtin_pow_root (location_t loc, tree arg0, tree arg1, tree type,
2974                          rtx subtarget)
2975 {
2976   if (TREE_CODE (arg1) == REAL_CST
2977       && !TREE_OVERFLOW (arg1)
2978       && flag_unsafe_math_optimizations)
2979     {
2980       enum machine_mode mode = TYPE_MODE (type);
2981       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
2982       tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
2983       REAL_VALUE_TYPE c = TREE_REAL_CST (arg1);
2984       tree op = NULL_TREE;
2985
2986       if (sqrtfn)
2987         {
2988           /* Optimize pow (x, 0.5) into sqrt.  */
2989           if (REAL_VALUES_EQUAL (c, dconsthalf))
2990             op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
2991
2992           else
2993             {
2994               REAL_VALUE_TYPE dconst1_4 = dconst1;
2995               REAL_VALUE_TYPE dconst3_4;
2996               SET_REAL_EXP (&dconst1_4, REAL_EXP (&dconst1_4) - 2);
2997
2998               real_from_integer (&dconst3_4, VOIDmode, 3, 0, 0);
2999               SET_REAL_EXP (&dconst3_4, REAL_EXP (&dconst3_4) - 2);
3000
3001               /* Optimize pow (x, 0.25) into sqrt (sqrt (x)).  Assume on most
3002                  machines that a builtin sqrt instruction is smaller than a
3003                  call to pow with 0.25, so do this optimization even if
3004                  -Os.  */
3005               if (REAL_VALUES_EQUAL (c, dconst1_4))
3006                 {
3007                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3008                   op = build_call_nofold_loc (loc, sqrtfn, 1, op);
3009                 }
3010
3011               /* Optimize pow (x, 0.75) = sqrt (x) * sqrt (sqrt (x)) unless we
3012                  are optimizing for space.  */
3013               else if (optimize_insn_for_speed_p ()
3014                        && !TREE_SIDE_EFFECTS (arg0)
3015                        && REAL_VALUES_EQUAL (c, dconst3_4))
3016                 {
3017                   tree sqrt1 = build_call_expr_loc (loc, sqrtfn, 1, arg0);
3018                   tree sqrt2 = builtin_save_expr (sqrt1);
3019                   tree sqrt3 = build_call_expr_loc (loc, sqrtfn, 1, sqrt1);
3020                   op = fold_build2_loc (loc, MULT_EXPR, type, sqrt2, sqrt3);
3021                 }
3022             }
3023         }
3024
3025       /* Check whether we can do cbrt insstead of pow (x, 1./3.) and
3026          cbrt/sqrts instead of pow (x, 1./6.).  */
3027       if (cbrtfn && ! op
3028           && (tree_expr_nonnegative_p (arg0) || !HONOR_NANS (mode)))
3029         {
3030           /* First try 1/3.  */
3031           REAL_VALUE_TYPE dconst1_3
3032             = real_value_truncate (mode, dconst_third ());
3033
3034           if (REAL_VALUES_EQUAL (c, dconst1_3))
3035             op = build_call_nofold_loc (loc, cbrtfn, 1, arg0);
3036
3037               /* Now try 1/6.  */
3038           else if (optimize_insn_for_speed_p ())
3039             {
3040               REAL_VALUE_TYPE dconst1_6 = dconst1_3;
3041               SET_REAL_EXP (&dconst1_6, REAL_EXP (&dconst1_6) - 1);
3042
3043               if (REAL_VALUES_EQUAL (c, dconst1_6))
3044                 {
3045                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3046                   op = build_call_nofold_loc (loc, cbrtfn, 1, op);
3047                 }
3048             }
3049         }
3050
3051       if (op)
3052         return expand_expr (op, subtarget, mode, EXPAND_NORMAL);
3053     }
3054
3055   return NULL_RTX;
3056 }
3057
3058 /* Expand a call to the pow built-in mathematical function.  Return NULL_RTX if
3059    a normal call should be emitted rather than expanding the function
3060    in-line.  EXP is the expression that is a call to the builtin
3061    function; if convenient, the result should be placed in TARGET.  */
3062
3063 static rtx
3064 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
3065 {
3066   tree arg0, arg1;
3067   tree fn, narg0;
3068   tree type = TREE_TYPE (exp);
3069   REAL_VALUE_TYPE cint, c, c2;
3070   HOST_WIDE_INT n;
3071   rtx op, op2;
3072   enum machine_mode mode = TYPE_MODE (type);
3073
3074   if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
3075     return NULL_RTX;
3076
3077   arg0 = CALL_EXPR_ARG (exp, 0);
3078   arg1 = CALL_EXPR_ARG (exp, 1);
3079
3080   if (TREE_CODE (arg1) != REAL_CST
3081       || TREE_OVERFLOW (arg1))
3082     return expand_builtin_mathfn_2 (exp, target, subtarget);
3083
3084   /* Handle constant exponents.  */
3085
3086   /* For integer valued exponents we can expand to an optimal multiplication
3087      sequence using expand_powi.  */
3088   c = TREE_REAL_CST (arg1);
3089   n = real_to_integer (&c);
3090   real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3091   if (real_identical (&c, &cint)
3092       && ((n >= -1 && n <= 2)
3093           || (flag_unsafe_math_optimizations
3094               && optimize_insn_for_speed_p ()
3095               && powi_cost (n) <= POWI_MAX_MULTS)))
3096     {
3097       op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3098       if (n != 1)
3099         {
3100           op = force_reg (mode, op);
3101           op = expand_powi (op, mode, n);
3102         }
3103       return op;
3104     }
3105
3106   narg0 = builtin_save_expr (arg0);
3107
3108   /* If the exponent is not integer valued, check if it is half of an integer.
3109      In this case we can expand to sqrt (x) * x**(n/2).  */
3110   fn = mathfn_built_in (type, BUILT_IN_SQRT);
3111   if (fn != NULL_TREE)
3112     {
3113       real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
3114       n = real_to_integer (&c2);
3115       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3116       if (real_identical (&c2, &cint)
3117           && ((flag_unsafe_math_optimizations
3118                && optimize_insn_for_speed_p ()
3119                && powi_cost (n/2) <= POWI_MAX_MULTS)
3120               /* Even the c == 0.5 case cannot be done unconditionally
3121                  when we need to preserve signed zeros, as
3122                  pow (-0, 0.5) is +0, while sqrt(-0) is -0.  */
3123               || (!HONOR_SIGNED_ZEROS (mode) && n == 1)
3124               /* For c == 1.5 we can assume that x * sqrt (x) is always
3125                  smaller than pow (x, 1.5) if sqrt will not be expanded
3126                  as a call.  */
3127               || (n == 3
3128                   && optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)))
3129         {
3130           tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3131                                                   narg0);
3132           /* Use expand_expr in case the newly built call expression
3133              was folded to a non-call.  */
3134           op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
3135           if (n != 1)
3136             {
3137               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3138               op2 = force_reg (mode, op2);
3139               op2 = expand_powi (op2, mode, abs (n / 2));
3140               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3141                                         0, OPTAB_LIB_WIDEN);
3142               /* If the original exponent was negative, reciprocate the
3143                  result.  */
3144               if (n < 0)
3145                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3146                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3147             }
3148           return op;
3149         }
3150     }
3151
3152   /* Check whether we can do a series of sqrt or cbrt's instead of the pow
3153      call.  */
3154   op = expand_builtin_pow_root (EXPR_LOCATION (exp), arg0, arg1, type,
3155                                 subtarget);
3156   if (op)
3157     return op;
3158
3159   /* Try if the exponent is a third of an integer.  In this case
3160      we can expand to x**(n/3) * cbrt(x)**(n%3).  As cbrt (x) is
3161      different from pow (x, 1./3.) due to rounding and behavior
3162      with negative x we need to constrain this transformation to
3163      unsafe math and positive x or finite math.  */
3164   fn = mathfn_built_in (type, BUILT_IN_CBRT);
3165   if (fn != NULL_TREE
3166       && flag_unsafe_math_optimizations
3167       && (tree_expr_nonnegative_p (arg0)
3168           || !HONOR_NANS (mode)))
3169     {
3170       REAL_VALUE_TYPE dconst3;
3171       real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3172       real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3173       real_round (&c2, mode, &c2);
3174       n = real_to_integer (&c2);
3175       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3176       real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3177       real_convert (&c2, mode, &c2);
3178       if (real_identical (&c2, &c)
3179           && ((optimize_insn_for_speed_p ()
3180                && powi_cost (n/3) <= POWI_MAX_MULTS)
3181               || n == 1))
3182         {
3183           tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3184                                                   narg0);
3185           op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3186           if (abs (n) % 3 == 2)
3187             op = expand_simple_binop (mode, MULT, op, op, op,
3188                                       0, OPTAB_LIB_WIDEN);
3189           if (n != 1)
3190             {
3191               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3192               op2 = force_reg (mode, op2);
3193               op2 = expand_powi (op2, mode, abs (n / 3));
3194               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3195                                         0, OPTAB_LIB_WIDEN);
3196               /* If the original exponent was negative, reciprocate the
3197                  result.  */
3198               if (n < 0)
3199                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3200                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3201             }
3202           return op;
3203         }
3204     }
3205
3206   /* Fall back to optab expansion.  */
3207   return expand_builtin_mathfn_2 (exp, target, subtarget);
3208 }
3209
3210 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
3211    a normal call should be emitted rather than expanding the function
3212    in-line.  EXP is the expression that is a call to the builtin
3213    function; if convenient, the result should be placed in TARGET.  */
3214
3215 static rtx
3216 expand_builtin_powi (tree exp, rtx target)
3217 {
3218   tree arg0, arg1;
3219   rtx op0, op1;
3220   enum machine_mode mode;
3221   enum machine_mode mode2;
3222
3223   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3224     return NULL_RTX;
3225
3226   arg0 = CALL_EXPR_ARG (exp, 0);
3227   arg1 = CALL_EXPR_ARG (exp, 1);
3228   mode = TYPE_MODE (TREE_TYPE (exp));
3229
3230   /* Handle constant power.  */
3231
3232   if (TREE_CODE (arg1) == INTEGER_CST
3233       && !TREE_OVERFLOW (arg1))
3234     {
3235       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3236
3237       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3238          Otherwise, check the number of multiplications required.  */
3239       if ((TREE_INT_CST_HIGH (arg1) == 0
3240            || TREE_INT_CST_HIGH (arg1) == -1)
3241           && ((n >= -1 && n <= 2)
3242               || (optimize_insn_for_speed_p ()
3243                   && powi_cost (n) <= POWI_MAX_MULTS)))
3244         {
3245           op0 = expand_expr (arg0, NULL_RTX, VOIDmode, EXPAND_NORMAL);
3246           op0 = force_reg (mode, op0);
3247           return expand_powi (op0, mode, n);
3248         }
3249     }
3250
3251   /* Emit a libcall to libgcc.  */
3252
3253   /* Mode of the 2nd argument must match that of an int.  */
3254   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3255
3256   if (target == NULL_RTX)
3257     target = gen_reg_rtx (mode);
3258
3259   op0 = expand_expr (arg0, NULL_RTX, mode, EXPAND_NORMAL);
3260   if (GET_MODE (op0) != mode)
3261     op0 = convert_to_mode (mode, op0, 0);
3262   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3263   if (GET_MODE (op1) != mode2)
3264     op1 = convert_to_mode (mode2, op1, 0);
3265
3266   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3267                                     target, LCT_CONST, mode, 2,
3268                                     op0, mode, op1, mode2);
3269
3270   return target;
3271 }
3272
3273 /* Expand expression EXP which is a call to the strlen builtin.  Return
3274    NULL_RTX if we failed the caller should emit a normal call, otherwise
3275    try to get the result in TARGET, if convenient.  */
3276
3277 static rtx
3278 expand_builtin_strlen (tree exp, rtx target,
3279                        enum machine_mode target_mode)
3280 {
3281   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3282     return NULL_RTX;
3283   else
3284     {
3285       rtx pat;
3286       tree len;
3287       tree src = CALL_EXPR_ARG (exp, 0);
3288       rtx result, src_reg, char_rtx, before_strlen;
3289       enum machine_mode insn_mode = target_mode, char_mode;
3290       enum insn_code icode = CODE_FOR_nothing;
3291       unsigned int align;
3292
3293       /* If the length can be computed at compile-time, return it.  */
3294       len = c_strlen (src, 0);
3295       if (len)
3296         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3297
3298       /* If the length can be computed at compile-time and is constant
3299          integer, but there are side-effects in src, evaluate
3300          src for side-effects, then return len.
3301          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3302          can be optimized into: i++; x = 3;  */
3303       len = c_strlen (src, 1);
3304       if (len && TREE_CODE (len) == INTEGER_CST)
3305         {
3306           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3307           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3308         }
3309
3310       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3311
3312       /* If SRC is not a pointer type, don't do this operation inline.  */
3313       if (align == 0)
3314         return NULL_RTX;
3315
3316       /* Bail out if we can't compute strlen in the right mode.  */
3317       while (insn_mode != VOIDmode)
3318         {
3319           icode = optab_handler (strlen_optab, insn_mode);
3320           if (icode != CODE_FOR_nothing)
3321             break;
3322
3323           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3324         }
3325       if (insn_mode == VOIDmode)
3326         return NULL_RTX;
3327
3328       /* Make a place to write the result of the instruction.  */
3329       result = target;
3330       if (! (result != 0
3331              && REG_P (result)
3332              && GET_MODE (result) == insn_mode
3333              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3334         result = gen_reg_rtx (insn_mode);
3335
3336       /* Make a place to hold the source address.  We will not expand
3337          the actual source until we are sure that the expansion will
3338          not fail -- there are trees that cannot be expanded twice.  */
3339       src_reg = gen_reg_rtx (Pmode);
3340
3341       /* Mark the beginning of the strlen sequence so we can emit the
3342          source operand later.  */
3343       before_strlen = get_last_insn ();
3344
3345       char_rtx = const0_rtx;
3346       char_mode = insn_data[(int) icode].operand[2].mode;
3347       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3348                                                             char_mode))
3349         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3350
3351       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3352                              char_rtx, GEN_INT (align));
3353       if (! pat)
3354         return NULL_RTX;
3355       emit_insn (pat);
3356
3357       /* Now that we are assured of success, expand the source.  */
3358       start_sequence ();
3359       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3360       if (pat != src_reg)
3361         emit_move_insn (src_reg, pat);
3362       pat = get_insns ();
3363       end_sequence ();
3364
3365       if (before_strlen)
3366         emit_insn_after (pat, before_strlen);
3367       else
3368         emit_insn_before (pat, get_insns ());
3369
3370       /* Return the value in the proper mode for this function.  */
3371       if (GET_MODE (result) == target_mode)
3372         target = result;
3373       else if (target != 0)
3374         convert_move (target, result, 0);
3375       else
3376         target = convert_to_mode (target_mode, result, 0);
3377
3378       return target;
3379     }
3380 }
3381
3382 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3383    bytes from constant string DATA + OFFSET and return it as target
3384    constant.  */
3385
3386 static rtx
3387 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3388                          enum machine_mode mode)
3389 {
3390   const char *str = (const char *) data;
3391
3392   gcc_assert (offset >= 0
3393               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3394                   <= strlen (str) + 1));
3395
3396   return c_readstr (str + offset, mode);
3397 }
3398
3399 /* Expand a call EXP to the memcpy builtin.
3400    Return NULL_RTX if we failed, the caller should emit a normal call,
3401    otherwise try to get the result in TARGET, if convenient (and in
3402    mode MODE if that's convenient).  */
3403
3404 static rtx
3405 expand_builtin_memcpy (tree exp, rtx target)
3406 {
3407   if (!validate_arglist (exp,
3408                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3409     return NULL_RTX;
3410   else
3411     {
3412       tree dest = CALL_EXPR_ARG (exp, 0);
3413       tree src = CALL_EXPR_ARG (exp, 1);
3414       tree len = CALL_EXPR_ARG (exp, 2);
3415       const char *src_str;
3416       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3417       unsigned int dest_align
3418         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3419       rtx dest_mem, src_mem, dest_addr, len_rtx;
3420       HOST_WIDE_INT expected_size = -1;
3421       unsigned int expected_align = 0;
3422
3423       /* If DEST is not a pointer type, call the normal function.  */
3424       if (dest_align == 0)
3425         return NULL_RTX;
3426
3427       /* If either SRC is not a pointer type, don't do this
3428          operation in-line.  */
3429       if (src_align == 0)
3430         return NULL_RTX;
3431
3432       if (currently_expanding_gimple_stmt)
3433         stringop_block_profile (currently_expanding_gimple_stmt,
3434                                 &expected_align, &expected_size);
3435
3436       if (expected_align < dest_align)
3437         expected_align = dest_align;
3438       dest_mem = get_memory_rtx (dest, len);
3439       set_mem_align (dest_mem, dest_align);
3440       len_rtx = expand_normal (len);
3441       src_str = c_getstr (src);
3442
3443       /* If SRC is a string constant and block move would be done
3444          by pieces, we can avoid loading the string from memory
3445          and only stored the computed constants.  */
3446       if (src_str
3447           && CONST_INT_P (len_rtx)
3448           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3449           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3450                                   CONST_CAST (char *, src_str),
3451                                   dest_align, false))
3452         {
3453           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3454                                       builtin_memcpy_read_str,
3455                                       CONST_CAST (char *, src_str),
3456                                       dest_align, false, 0);
3457           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3458           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3459           return dest_mem;
3460         }
3461
3462       src_mem = get_memory_rtx (src, len);
3463       set_mem_align (src_mem, src_align);
3464
3465       /* Copy word part most expediently.  */
3466       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3467                                          CALL_EXPR_TAILCALL (exp)
3468                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3469                                          expected_align, expected_size);
3470
3471       if (dest_addr == 0)
3472         {
3473           dest_addr = force_operand (XEXP (dest_mem, 0), target);
3474           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3475         }
3476       return dest_addr;
3477     }
3478 }
3479
3480 /* Expand a call EXP to the mempcpy builtin.
3481    Return NULL_RTX if we failed; the caller should emit a normal call,
3482    otherwise try to get the result in TARGET, if convenient (and in
3483    mode MODE if that's convenient).  If ENDP is 0 return the
3484    destination pointer, if ENDP is 1 return the end pointer ala
3485    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3486    stpcpy.  */
3487
3488 static rtx
3489 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3490 {
3491   if (!validate_arglist (exp,
3492                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3493     return NULL_RTX;
3494   else
3495     {
3496       tree dest = CALL_EXPR_ARG (exp, 0);
3497       tree src = CALL_EXPR_ARG (exp, 1);
3498       tree len = CALL_EXPR_ARG (exp, 2);
3499       return expand_builtin_mempcpy_args (dest, src, len,
3500                                           target, mode, /*endp=*/ 1);
3501     }
3502 }
3503
3504 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3505    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3506    so that this can also be called without constructing an actual CALL_EXPR.
3507    The other arguments and return value are the same as for
3508    expand_builtin_mempcpy.  */
3509
3510 static rtx
3511 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3512                              rtx target, enum machine_mode mode, int endp)
3513 {
3514     /* If return value is ignored, transform mempcpy into memcpy.  */
3515   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3516     {
3517       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3518       tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3519                                            dest, src, len);
3520       return expand_expr (result, target, mode, EXPAND_NORMAL);
3521     }
3522   else
3523     {
3524       const char *src_str;
3525       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3526       unsigned int dest_align
3527         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3528       rtx dest_mem, src_mem, len_rtx;
3529
3530       /* If either SRC or DEST is not a pointer type, don't do this
3531          operation in-line.  */
3532       if (dest_align == 0 || src_align == 0)
3533         return NULL_RTX;
3534
3535       /* If LEN is not constant, call the normal function.  */
3536       if (! host_integerp (len, 1))
3537         return NULL_RTX;
3538
3539       len_rtx = expand_normal (len);
3540       src_str = c_getstr (src);
3541
3542       /* If SRC is a string constant and block move would be done
3543          by pieces, we can avoid loading the string from memory
3544          and only stored the computed constants.  */
3545       if (src_str
3546           && CONST_INT_P (len_rtx)
3547           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3548           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3549                                   CONST_CAST (char *, src_str),
3550                                   dest_align, false))
3551         {
3552           dest_mem = get_memory_rtx (dest, len);
3553           set_mem_align (dest_mem, dest_align);
3554           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3555                                       builtin_memcpy_read_str,
3556                                       CONST_CAST (char *, src_str),
3557                                       dest_align, false, endp);
3558           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3559           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3560           return dest_mem;
3561         }
3562
3563       if (CONST_INT_P (len_rtx)
3564           && can_move_by_pieces (INTVAL (len_rtx),
3565                                  MIN (dest_align, src_align)))
3566         {
3567           dest_mem = get_memory_rtx (dest, len);
3568           set_mem_align (dest_mem, dest_align);
3569           src_mem = get_memory_rtx (src, len);
3570           set_mem_align (src_mem, src_align);
3571           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3572                                      MIN (dest_align, src_align), endp);
3573           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3574           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3575           return dest_mem;
3576         }
3577
3578       return NULL_RTX;
3579     }
3580 }
3581
3582 #ifndef HAVE_movstr
3583 # define HAVE_movstr 0
3584 # define CODE_FOR_movstr CODE_FOR_nothing
3585 #endif
3586
3587 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3588    we failed, the caller should emit a normal call, otherwise try to
3589    get the result in TARGET, if convenient.  If ENDP is 0 return the
3590    destination pointer, if ENDP is 1 return the end pointer ala
3591    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3592    stpcpy.  */
3593
3594 static rtx
3595 expand_movstr (tree dest, tree src, rtx target, int endp)
3596 {
3597   rtx end;
3598   rtx dest_mem;
3599   rtx src_mem;
3600   rtx insn;
3601   const struct insn_data_d * data;
3602
3603   if (!HAVE_movstr)
3604     return NULL_RTX;
3605
3606   dest_mem = get_memory_rtx (dest, NULL);
3607   src_mem = get_memory_rtx (src, NULL);
3608   data = insn_data + CODE_FOR_movstr;
3609   if (!endp)
3610     {
3611       target = force_reg (Pmode, XEXP (dest_mem, 0));
3612       dest_mem = replace_equiv_address (dest_mem, target);
3613       end = gen_reg_rtx (Pmode);
3614     }
3615   else
3616     {
3617       if (target == 0
3618           || target == const0_rtx
3619           || ! (*data->operand[0].predicate) (target, Pmode))
3620         {
3621           end = gen_reg_rtx (Pmode);
3622           if (target != const0_rtx)
3623             target = end;
3624         }
3625       else
3626         end = target;
3627     }
3628
3629   if (data->operand[0].mode != VOIDmode)
3630     end = gen_lowpart (data->operand[0].mode, end);
3631
3632   insn = data->genfun (end, dest_mem, src_mem);
3633
3634   gcc_assert (insn);
3635
3636   emit_insn (insn);
3637
3638   /* movstr is supposed to set end to the address of the NUL
3639      terminator.  If the caller requested a mempcpy-like return value,
3640      adjust it.  */
3641   if (endp == 1 && target != const0_rtx)
3642     {
3643       rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3644       emit_move_insn (target, force_operand (tem, NULL_RTX));
3645     }
3646
3647   return target;
3648 }
3649
3650 /* Expand expression EXP, which is a call to the strcpy builtin.  Return
3651    NULL_RTX if we failed the caller should emit a normal call, otherwise
3652    try to get the result in TARGET, if convenient (and in mode MODE if that's
3653    convenient).  */
3654
3655 static rtx
3656 expand_builtin_strcpy (tree exp, rtx target)
3657 {
3658   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3659    {
3660      tree dest = CALL_EXPR_ARG (exp, 0);
3661      tree src = CALL_EXPR_ARG (exp, 1);
3662      return expand_builtin_strcpy_args (dest, src, target);
3663    }
3664    return NULL_RTX;
3665 }
3666
3667 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3668    arguments to the builtin_strcpy call DEST and SRC are broken out
3669    so that this can also be called without constructing an actual CALL_EXPR.
3670    The other arguments and return value are the same as for
3671    expand_builtin_strcpy.  */
3672
3673 static rtx
3674 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3675 {
3676   return expand_movstr (dest, src, target, /*endp=*/0);
3677 }
3678
3679 /* Expand a call EXP to the stpcpy builtin.
3680    Return NULL_RTX if we failed the caller should emit a normal call,
3681    otherwise try to get the result in TARGET, if convenient (and in
3682    mode MODE if that's convenient).  */
3683
3684 static rtx
3685 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3686 {
3687   tree dst, src;
3688   location_t loc = EXPR_LOCATION (exp);
3689
3690   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3691     return NULL_RTX;
3692
3693   dst = CALL_EXPR_ARG (exp, 0);
3694   src = CALL_EXPR_ARG (exp, 1);
3695
3696   /* If return value is ignored, transform stpcpy into strcpy.  */
3697   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3698     {
3699       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3700       tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3701       return expand_expr (result, target, mode, EXPAND_NORMAL);
3702     }
3703   else
3704     {
3705       tree len, lenp1;
3706       rtx ret;
3707
3708       /* Ensure we get an actual string whose length can be evaluated at
3709          compile-time, not an expression containing a string.  This is
3710          because the latter will potentially produce pessimized code
3711          when used to produce the return value.  */
3712       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3713         return expand_movstr (dst, src, target, /*endp=*/2);
3714
3715       lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3716       ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3717                                          target, mode, /*endp=*/2);
3718
3719       if (ret)
3720         return ret;
3721
3722       if (TREE_CODE (len) == INTEGER_CST)
3723         {
3724           rtx len_rtx = expand_normal (len);
3725
3726           if (CONST_INT_P (len_rtx))
3727             {
3728               ret = expand_builtin_strcpy_args (dst, src, target);
3729
3730               if (ret)
3731                 {
3732                   if (! target)
3733                     {
3734                       if (mode != VOIDmode)
3735                         target = gen_reg_rtx (mode);
3736                       else
3737                         target = gen_reg_rtx (GET_MODE (ret));
3738                     }
3739                   if (GET_MODE (target) != GET_MODE (ret))
3740                     ret = gen_lowpart (GET_MODE (target), ret);
3741
3742                   ret = plus_constant (ret, INTVAL (len_rtx));
3743                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3744                   gcc_assert (ret);
3745
3746                   return target;
3747                 }
3748             }
3749         }
3750
3751       return expand_movstr (dst, src, target, /*endp=*/2);
3752     }
3753 }
3754
3755 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3756    bytes from constant string DATA + OFFSET and return it as target
3757    constant.  */
3758
3759 rtx
3760 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3761                           enum machine_mode mode)
3762 {
3763   const char *str = (const char *) data;
3764
3765   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3766     return const0_rtx;
3767
3768   return c_readstr (str + offset, mode);
3769 }
3770
3771 /* Expand expression EXP, which is a call to the strncpy builtin.  Return
3772    NULL_RTX if we failed the caller should emit a normal call.  */
3773
3774 static rtx
3775 expand_builtin_strncpy (tree exp, rtx target)
3776 {
3777   location_t loc = EXPR_LOCATION (exp);
3778
3779   if (validate_arglist (exp,
3780                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3781     {
3782       tree dest = CALL_EXPR_ARG (exp, 0);
3783       tree src = CALL_EXPR_ARG (exp, 1);
3784       tree len = CALL_EXPR_ARG (exp, 2);
3785       tree slen = c_strlen (src, 1);
3786
3787       /* We must be passed a constant len and src parameter.  */
3788       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3789         return NULL_RTX;
3790
3791       slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3792
3793       /* We're required to pad with trailing zeros if the requested
3794          len is greater than strlen(s2)+1.  In that case try to
3795          use store_by_pieces, if it fails, punt.  */
3796       if (tree_int_cst_lt (slen, len))
3797         {
3798           unsigned int dest_align
3799             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3800           const char *p = c_getstr (src);
3801           rtx dest_mem;
3802
3803           if (!p || dest_align == 0 || !host_integerp (len, 1)
3804               || !can_store_by_pieces (tree_low_cst (len, 1),
3805                                        builtin_strncpy_read_str,
3806                                        CONST_CAST (char *, p),
3807                                        dest_align, false))
3808             return NULL_RTX;
3809
3810           dest_mem = get_memory_rtx (dest, len);
3811           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3812                            builtin_strncpy_read_str,
3813                            CONST_CAST (char *, p), dest_align, false, 0);
3814           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3815           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3816           return dest_mem;
3817         }
3818     }
3819   return NULL_RTX;
3820 }
3821
3822 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3823    bytes from constant string DATA + OFFSET and return it as target
3824    constant.  */
3825
3826 rtx
3827 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3828                          enum machine_mode mode)
3829 {
3830   const char *c = (const char *) data;
3831   char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3832
3833   memset (p, *c, GET_MODE_SIZE (mode));
3834
3835   return c_readstr (p, mode);
3836 }
3837
3838 /* Callback routine for store_by_pieces.  Return the RTL of a register
3839    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3840    char value given in the RTL register data.  For example, if mode is
3841    4 bytes wide, return the RTL for 0x01010101*data.  */
3842
3843 static rtx
3844 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3845                         enum machine_mode mode)
3846 {
3847   rtx target, coeff;
3848   size_t size;
3849   char *p;
3850
3851   size = GET_MODE_SIZE (mode);
3852   if (size == 1)
3853     return (rtx) data;
3854
3855   p = XALLOCAVEC (char, size);
3856   memset (p, 1, size);
3857   coeff = c_readstr (p, mode);
3858
3859   target = convert_to_mode (mode, (rtx) data, 1);
3860   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3861   return force_reg (mode, target);
3862 }
3863
3864 /* Expand expression EXP, which is a call to the memset builtin.  Return
3865    NULL_RTX if we failed the caller should emit a normal call, otherwise
3866    try to get the result in TARGET, if convenient (and in mode MODE if that's
3867    convenient).  */
3868
3869 static rtx
3870 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3871 {
3872   if (!validate_arglist (exp,
3873                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3874     return NULL_RTX;
3875   else
3876     {
3877       tree dest = CALL_EXPR_ARG (exp, 0);
3878       tree val = CALL_EXPR_ARG (exp, 1);
3879       tree len = CALL_EXPR_ARG (exp, 2);
3880       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3881     }
3882 }
3883
3884 /* Helper function to do the actual work for expand_builtin_memset.  The
3885    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3886    so that this can also be called without constructing an actual CALL_EXPR.
3887    The other arguments and return value are the same as for
3888    expand_builtin_memset.  */
3889
3890 static rtx
3891 expand_builtin_memset_args (tree dest, tree val, tree len,
3892                             rtx target, enum machine_mode mode, tree orig_exp)
3893 {
3894   tree fndecl, fn;
3895   enum built_in_function fcode;
3896   char c;
3897   unsigned int dest_align;
3898   rtx dest_mem, dest_addr, len_rtx;
3899   HOST_WIDE_INT expected_size = -1;
3900   unsigned int expected_align = 0;
3901
3902   dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3903
3904   /* If DEST is not a pointer type, don't do this operation in-line.  */
3905   if (dest_align == 0)
3906     return NULL_RTX;
3907
3908   if (currently_expanding_gimple_stmt)
3909     stringop_block_profile (currently_expanding_gimple_stmt,
3910                             &expected_align, &expected_size);
3911
3912   if (expected_align < dest_align)
3913     expected_align = dest_align;
3914
3915   /* If the LEN parameter is zero, return DEST.  */
3916   if (integer_zerop (len))
3917     {
3918       /* Evaluate and ignore VAL in case it has side-effects.  */
3919       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3920       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3921     }
3922
3923   /* Stabilize the arguments in case we fail.  */
3924   dest = builtin_save_expr (dest);
3925   val = builtin_save_expr (val);
3926   len = builtin_save_expr (len);
3927
3928   len_rtx = expand_normal (len);
3929   dest_mem = get_memory_rtx (dest, len);
3930
3931   if (TREE_CODE (val) != INTEGER_CST)
3932     {
3933       rtx val_rtx;
3934
3935       val_rtx = expand_normal (val);
3936       val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3937                                  val_rtx, 0);
3938
3939       /* Assume that we can memset by pieces if we can store
3940        * the coefficients by pieces (in the required modes).
3941        * We can't pass builtin_memset_gen_str as that emits RTL.  */
3942       c = 1;
3943       if (host_integerp (len, 1)
3944           && can_store_by_pieces (tree_low_cst (len, 1),
3945                                   builtin_memset_read_str, &c, dest_align,
3946                                   true))
3947         {
3948           val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3949                                val_rtx);
3950           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3951                            builtin_memset_gen_str, val_rtx, dest_align,
3952                            true, 0);
3953         }
3954       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3955                                         dest_align, expected_align,
3956                                         expected_size))
3957         goto do_libcall;
3958
3959       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3960       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3961       return dest_mem;
3962     }
3963
3964   if (target_char_cast (val, &c))
3965     goto do_libcall;
3966
3967   if (c)
3968     {
3969       if (host_integerp (len, 1)
3970           && can_store_by_pieces (tree_low_cst (len, 1),
3971                                   builtin_memset_read_str, &c, dest_align,
3972                                   true))
3973         store_by_pieces (dest_mem, tree_low_cst (len, 1),
3974                          builtin_memset_read_str, &c, dest_align, true, 0);
3975       else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3976                                         dest_align, expected_align,
3977                                         expected_size))
3978         goto do_libcall;
3979
3980       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3981       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3982       return dest_mem;
3983     }
3984
3985   set_mem_align (dest_mem, dest_align);
3986   dest_addr = clear_storage_hints (dest_mem, len_rtx,
3987                                    CALL_EXPR_TAILCALL (orig_exp)
3988                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3989                                    expected_align, expected_size);
3990
3991   if (dest_addr == 0)
3992     {
3993       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3994       dest_addr = convert_memory_address (ptr_mode, dest_addr);
3995     }
3996
3997   return dest_addr;
3998
3999  do_libcall:
4000   fndecl = get_callee_fndecl (orig_exp);
4001   fcode = DECL_FUNCTION_CODE (fndecl);
4002   if (fcode == BUILT_IN_MEMSET)
4003     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
4004                                 dest, val, len);
4005   else if (fcode == BUILT_IN_BZERO)
4006     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
4007                                 dest, len);
4008   else
4009     gcc_unreachable ();
4010   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4011   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
4012   return expand_call (fn, target, target == const0_rtx);
4013 }
4014
4015 /* Expand expression EXP, which is a call to the bzero builtin.  Return
4016    NULL_RTX if we failed the caller should emit a normal call.  */
4017
4018 static rtx
4019 expand_builtin_bzero (tree exp)
4020 {
4021   tree dest, size;
4022   location_t loc = EXPR_LOCATION (exp);
4023
4024   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4025     return NULL_RTX;
4026
4027   dest = CALL_EXPR_ARG (exp, 0);
4028   size = CALL_EXPR_ARG (exp, 1);
4029
4030   /* New argument list transforming bzero(ptr x, int y) to
4031      memset(ptr x, int 0, size_t y).   This is done this way
4032      so that if it isn't expanded inline, we fallback to
4033      calling bzero instead of memset.  */
4034
4035   return expand_builtin_memset_args (dest, integer_zero_node,
4036                                      fold_convert_loc (loc, sizetype, size),
4037                                      const0_rtx, VOIDmode, exp);
4038 }
4039
4040 /* Expand expression EXP, which is a call to the memcmp built-in function.
4041    Return NULL_RTX if we failed and the
4042    caller should emit a normal call, otherwise try to get the result in
4043    TARGET, if convenient (and in mode MODE, if that's convenient).  */
4044
4045 static rtx
4046 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4047                        ATTRIBUTE_UNUSED enum machine_mode mode)
4048 {
4049   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4050
4051   if (!validate_arglist (exp,
4052                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4053     return NULL_RTX;
4054
4055 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4056   {
4057     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4058     rtx result;
4059     rtx insn;
4060     tree arg1 = CALL_EXPR_ARG (exp, 0);
4061     tree arg2 = CALL_EXPR_ARG (exp, 1);
4062     tree len = CALL_EXPR_ARG (exp, 2);
4063
4064     unsigned int arg1_align
4065       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4066     unsigned int arg2_align
4067       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4068     enum machine_mode insn_mode;
4069
4070 #ifdef HAVE_cmpmemsi
4071     if (HAVE_cmpmemsi)
4072       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
4073     else
4074 #endif
4075 #ifdef HAVE_cmpstrnsi
4076     if (HAVE_cmpstrnsi)
4077       insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4078     else
4079 #endif
4080       return NULL_RTX;
4081
4082     /* If we don't have POINTER_TYPE, call the function.  */
4083     if (arg1_align == 0 || arg2_align == 0)
4084       return NULL_RTX;
4085
4086     /* Make a place to write the result of the instruction.  */
4087     result = target;
4088     if (! (result != 0
4089            && REG_P (result) && GET_MODE (result) == insn_mode
4090            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4091       result = gen_reg_rtx (insn_mode);
4092
4093     arg1_rtx = get_memory_rtx (arg1, len);
4094     arg2_rtx = get_memory_rtx (arg2, len);
4095     arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
4096
4097     /* Set MEM_SIZE as appropriate.  */
4098     if (CONST_INT_P (arg3_rtx))
4099       {
4100         set_mem_size (arg1_rtx, arg3_rtx);
4101         set_mem_size (arg2_rtx, arg3_rtx);
4102       }
4103
4104 #ifdef HAVE_cmpmemsi
4105     if (HAVE_cmpmemsi)
4106       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4107                            GEN_INT (MIN (arg1_align, arg2_align)));
4108     else
4109 #endif
4110 #ifdef HAVE_cmpstrnsi
4111     if (HAVE_cmpstrnsi)
4112       insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4113                             GEN_INT (MIN (arg1_align, arg2_align)));
4114     else
4115 #endif
4116       gcc_unreachable ();
4117
4118     if (insn)
4119       emit_insn (insn);
4120     else
4121       emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
4122                                TYPE_MODE (integer_type_node), 3,
4123                                XEXP (arg1_rtx, 0), Pmode,
4124                                XEXP (arg2_rtx, 0), Pmode,
4125                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
4126                                                 TYPE_UNSIGNED (sizetype)),
4127                                TYPE_MODE (sizetype));
4128
4129     /* Return the value in the proper mode for this function.  */
4130     mode = TYPE_MODE (TREE_TYPE (exp));
4131     if (GET_MODE (result) == mode)
4132       return result;
4133     else if (target != 0)
4134       {
4135         convert_move (target, result, 0);
4136         return target;
4137       }
4138     else
4139       return convert_to_mode (mode, result, 0);
4140   }
4141 #endif
4142
4143   return NULL_RTX;
4144 }
4145
4146 /* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
4147    if we failed the caller should emit a normal call, otherwise try to get
4148    the result in TARGET, if convenient.  */
4149
4150 static rtx
4151 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
4152 {
4153   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4154     return NULL_RTX;
4155
4156 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4157   if (direct_optab_handler (cmpstr_optab, SImode) != CODE_FOR_nothing
4158       || direct_optab_handler (cmpstrn_optab, SImode) != CODE_FOR_nothing)
4159     {
4160       rtx arg1_rtx, arg2_rtx;
4161       rtx result, insn = NULL_RTX;
4162       tree fndecl, fn;
4163       tree arg1 = CALL_EXPR_ARG (exp, 0);
4164       tree arg2 = CALL_EXPR_ARG (exp, 1);
4165
4166       unsigned int arg1_align
4167         = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4168       unsigned int arg2_align
4169         = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4170
4171       /* If we don't have POINTER_TYPE, call the function.  */
4172       if (arg1_align == 0 || arg2_align == 0)
4173         return NULL_RTX;
4174
4175       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
4176       arg1 = builtin_save_expr (arg1);
4177       arg2 = builtin_save_expr (arg2);
4178
4179       arg1_rtx = get_memory_rtx (arg1, NULL);
4180       arg2_rtx = get_memory_rtx (arg2, NULL);
4181
4182 #ifdef HAVE_cmpstrsi
4183       /* Try to call cmpstrsi.  */
4184       if (HAVE_cmpstrsi)
4185         {
4186           enum machine_mode insn_mode
4187             = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4188
4189           /* Make a place to write the result of the instruction.  */
4190           result = target;
4191           if (! (result != 0
4192                  && REG_P (result) && GET_MODE (result) == insn_mode
4193                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4194             result = gen_reg_rtx (insn_mode);
4195
4196           insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4197                                GEN_INT (MIN (arg1_align, arg2_align)));
4198         }
4199 #endif
4200 #ifdef HAVE_cmpstrnsi
4201       /* Try to determine at least one length and call cmpstrnsi.  */
4202       if (!insn && HAVE_cmpstrnsi)
4203         {
4204           tree len;
4205           rtx arg3_rtx;
4206
4207           enum machine_mode insn_mode
4208             = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4209           tree len1 = c_strlen (arg1, 1);
4210           tree len2 = c_strlen (arg2, 1);
4211
4212           if (len1)
4213             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4214           if (len2)
4215             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4216
4217           /* If we don't have a constant length for the first, use the length
4218              of the second, if we know it.  We don't require a constant for
4219              this case; some cost analysis could be done if both are available
4220              but neither is constant.  For now, assume they're equally cheap,
4221              unless one has side effects.  If both strings have constant lengths,
4222              use the smaller.  */
4223
4224           if (!len1)
4225             len = len2;
4226           else if (!len2)
4227             len = len1;
4228           else if (TREE_SIDE_EFFECTS (len1))
4229             len = len2;
4230           else if (TREE_SIDE_EFFECTS (len2))
4231             len = len1;
4232           else if (TREE_CODE (len1) != INTEGER_CST)
4233             len = len2;
4234           else if (TREE_CODE (len2) != INTEGER_CST)
4235             len = len1;
4236           else if (tree_int_cst_lt (len1, len2))
4237             len = len1;
4238           else
4239             len = len2;
4240
4241           /* If both arguments have side effects, we cannot optimize.  */
4242           if (!len || TREE_SIDE_EFFECTS (len))
4243             goto do_libcall;
4244
4245           arg3_rtx = expand_normal (len);
4246
4247           /* Make a place to write the result of the instruction.  */
4248           result = target;
4249           if (! (result != 0
4250                  && REG_P (result) && GET_MODE (result) == insn_mode
4251                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4252             result = gen_reg_rtx (insn_mode);
4253
4254           insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4255                                 GEN_INT (MIN (arg1_align, arg2_align)));
4256         }
4257 #endif
4258
4259       if (insn)
4260         {
4261           enum machine_mode mode;
4262           emit_insn (insn);
4263
4264           /* Return the value in the proper mode for this function.  */
4265           mode = TYPE_MODE (TREE_TYPE (exp));
4266           if (GET_MODE (result) == mode)
4267             return result;
4268           if (target == 0)
4269             return convert_to_mode (mode, result, 0);
4270           convert_move (target, result, 0);
4271           return target;
4272         }
4273
4274       /* Expand the library call ourselves using a stabilized argument
4275          list to avoid re-evaluating the function's arguments twice.  */
4276 #ifdef HAVE_cmpstrnsi
4277     do_libcall:
4278 #endif
4279       fndecl = get_callee_fndecl (exp);
4280       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
4281       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4282       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4283       return expand_call (fn, target, target == const0_rtx);
4284     }
4285 #endif
4286   return NULL_RTX;
4287 }
4288
4289 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4290    NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4291    the result in TARGET, if convenient.  */
4292
4293 static rtx
4294 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4295                         ATTRIBUTE_UNUSED enum machine_mode mode)
4296 {
4297   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4298
4299   if (!validate_arglist (exp,
4300                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4301     return NULL_RTX;
4302
4303   /* If c_strlen can determine an expression for one of the string
4304      lengths, and it doesn't have side effects, then emit cmpstrnsi
4305      using length MIN(strlen(string)+1, arg3).  */
4306 #ifdef HAVE_cmpstrnsi
4307   if (HAVE_cmpstrnsi)
4308   {
4309     tree len, len1, len2;
4310     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4311     rtx result, insn;
4312     tree fndecl, fn;
4313     tree arg1 = CALL_EXPR_ARG (exp, 0);
4314     tree arg2 = CALL_EXPR_ARG (exp, 1);
4315     tree arg3 = CALL_EXPR_ARG (exp, 2);
4316
4317     unsigned int arg1_align
4318       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4319     unsigned int arg2_align
4320       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4321     enum machine_mode insn_mode
4322       = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4323
4324     len1 = c_strlen (arg1, 1);
4325     len2 = c_strlen (arg2, 1);
4326
4327     if (len1)
4328       len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
4329     if (len2)
4330       len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
4331
4332     /* If we don't have a constant length for the first, use the length
4333        of the second, if we know it.  We don't require a constant for
4334        this case; some cost analysis could be done if both are available
4335        but neither is constant.  For now, assume they're equally cheap,
4336        unless one has side effects.  If both strings have constant lengths,
4337        use the smaller.  */
4338
4339     if (!len1)
4340       len = len2;
4341     else if (!len2)
4342       len = len1;
4343     else if (TREE_SIDE_EFFECTS (len1))
4344       len = len2;
4345     else if (TREE_SIDE_EFFECTS (len2))
4346       len = len1;
4347     else if (TREE_CODE (len1) != INTEGER_CST)
4348       len = len2;
4349     else if (TREE_CODE (len2) != INTEGER_CST)
4350       len = len1;
4351     else if (tree_int_cst_lt (len1, len2))
4352       len = len1;
4353     else
4354       len = len2;
4355
4356     /* If both arguments have side effects, we cannot optimize.  */
4357     if (!len || TREE_SIDE_EFFECTS (len))
4358       return NULL_RTX;
4359
4360     /* The actual new length parameter is MIN(len,arg3).  */
4361     len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4362                        fold_convert_loc (loc, TREE_TYPE (len), arg3));
4363
4364     /* If we don't have POINTER_TYPE, call the function.  */
4365     if (arg1_align == 0 || arg2_align == 0)
4366       return NULL_RTX;
4367
4368     /* Make a place to write the result of the instruction.  */
4369     result = target;
4370     if (! (result != 0
4371            && REG_P (result) && GET_MODE (result) == insn_mode
4372            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4373       result = gen_reg_rtx (insn_mode);
4374
4375     /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
4376     arg1 = builtin_save_expr (arg1);
4377     arg2 = builtin_save_expr (arg2);
4378     len = builtin_save_expr (len);
4379
4380     arg1_rtx = get_memory_rtx (arg1, len);
4381     arg2_rtx = get_memory_rtx (arg2, len);
4382     arg3_rtx = expand_normal (len);
4383     insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4384                           GEN_INT (MIN (arg1_align, arg2_align)));
4385     if (insn)
4386       {
4387         emit_insn (insn);
4388
4389         /* Return the value in the proper mode for this function.  */
4390         mode = TYPE_MODE (TREE_TYPE (exp));
4391         if (GET_MODE (result) == mode)
4392           return result;
4393         if (target == 0)
4394           return convert_to_mode (mode, result, 0);
4395         convert_move (target, result, 0);
4396         return target;
4397       }
4398
4399     /* Expand the library call ourselves using a stabilized argument
4400        list to avoid re-evaluating the function's arguments twice.  */
4401     fndecl = get_callee_fndecl (exp);
4402     fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
4403                                 arg1, arg2, len);
4404     gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4405     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4406     return expand_call (fn, target, target == const0_rtx);
4407   }
4408 #endif
4409   return NULL_RTX;
4410 }
4411
4412 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4413    if that's convenient.  */
4414
4415 rtx
4416 expand_builtin_saveregs (void)
4417 {
4418   rtx val, seq;
4419
4420   /* Don't do __builtin_saveregs more than once in a function.
4421      Save the result of the first call and reuse it.  */
4422   if (saveregs_value != 0)
4423     return saveregs_value;
4424
4425   /* When this function is called, it means that registers must be
4426      saved on entry to this function.  So we migrate the call to the
4427      first insn of this function.  */
4428
4429   start_sequence ();
4430
4431   /* Do whatever the machine needs done in this case.  */
4432   val = targetm.calls.expand_builtin_saveregs ();
4433
4434   seq = get_insns ();
4435   end_sequence ();
4436
4437   saveregs_value = val;
4438
4439   /* Put the insns after the NOTE that starts the function.  If this
4440      is inside a start_sequence, make the outer-level insn chain current, so
4441      the code is placed at the start of the function.  */
4442   push_topmost_sequence ();
4443   emit_insn_after (seq, entry_of_function ());
4444   pop_topmost_sequence ();
4445
4446   return val;
4447 }
4448
4449 /* Expand a call to __builtin_next_arg.  */
4450
4451 static rtx
4452 expand_builtin_next_arg (void)
4453 {
4454   /* Checking arguments is already done in fold_builtin_next_arg
4455      that must be called before this function.  */
4456   return expand_binop (ptr_mode, add_optab,
4457                        crtl->args.internal_arg_pointer,
4458                        crtl->args.arg_offset_rtx,
4459                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
4460 }
4461
4462 /* Make it easier for the backends by protecting the valist argument
4463    from multiple evaluations.  */
4464
4465 static tree
4466 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4467 {
4468   tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4469
4470   /* The current way of determining the type of valist is completely
4471      bogus.  We should have the information on the va builtin instead.  */
4472   if (!vatype)
4473     vatype = targetm.fn_abi_va_list (cfun->decl);
4474
4475   if (TREE_CODE (vatype) == ARRAY_TYPE)
4476     {
4477       if (TREE_SIDE_EFFECTS (valist))
4478         valist = save_expr (valist);
4479
4480       /* For this case, the backends will be expecting a pointer to
4481          vatype, but it's possible we've actually been given an array
4482          (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4483          So fix it.  */
4484       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4485         {
4486           tree p1 = build_pointer_type (TREE_TYPE (vatype));
4487           valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4488         }
4489     }
4490   else
4491     {
4492       tree pt = build_pointer_type (vatype);
4493
4494       if (! needs_lvalue)
4495         {
4496           if (! TREE_SIDE_EFFECTS (valist))
4497             return valist;
4498
4499           valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4500           TREE_SIDE_EFFECTS (valist) = 1;
4501         }
4502
4503       if (TREE_SIDE_EFFECTS (valist))
4504         valist = save_expr (valist);
4505       valist = fold_build2_loc (loc, MEM_REF,
4506                                 vatype, valist, build_int_cst (pt, 0));
4507     }
4508
4509   return valist;
4510 }
4511
4512 /* The "standard" definition of va_list is void*.  */
4513
4514 tree
4515 std_build_builtin_va_list (void)
4516 {
4517   return ptr_type_node;
4518 }
4519
4520 /* The "standard" abi va_list is va_list_type_node.  */
4521
4522 tree
4523 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4524 {
4525   return va_list_type_node;
4526 }
4527
4528 /* The "standard" type of va_list is va_list_type_node.  */
4529
4530 tree
4531 std_canonical_va_list_type (tree type)
4532 {
4533   tree wtype, htype;
4534
4535   if (INDIRECT_REF_P (type))
4536     type = TREE_TYPE (type);
4537   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4538     type = TREE_TYPE (type);
4539   wtype = va_list_type_node;
4540   htype = type;
4541   /* Treat structure va_list types.  */
4542   if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4543     htype = TREE_TYPE (htype);
4544   else if (TREE_CODE (wtype) == ARRAY_TYPE)
4545     {
4546       /* If va_list is an array type, the argument may have decayed
4547          to a pointer type, e.g. by being passed to another function.
4548          In that case, unwrap both types so that we can compare the
4549          underlying records.  */
4550       if (TREE_CODE (htype) == ARRAY_TYPE
4551           || POINTER_TYPE_P (htype))
4552         {
4553           wtype = TREE_TYPE (wtype);
4554           htype = TREE_TYPE (htype);
4555         }
4556     }
4557   if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4558     return va_list_type_node;
4559
4560   return NULL_TREE;
4561 }
4562
4563 /* The "standard" implementation of va_start: just assign `nextarg' to
4564    the variable.  */
4565
4566 void
4567 std_expand_builtin_va_start (tree valist, rtx nextarg)
4568 {
4569   rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4570   convert_move (va_r, nextarg, 0);
4571 }
4572
4573 /* Expand EXP, a call to __builtin_va_start.  */
4574
4575 static rtx
4576 expand_builtin_va_start (tree exp)
4577 {
4578   rtx nextarg;
4579   tree valist;
4580   location_t loc = EXPR_LOCATION (exp);
4581
4582   if (call_expr_nargs (exp) < 2)
4583     {
4584       error_at (loc, "too few arguments to function %<va_start%>");
4585       return const0_rtx;
4586     }
4587
4588   if (fold_builtin_next_arg (exp, true))
4589     return const0_rtx;
4590
4591   nextarg = expand_builtin_next_arg ();
4592   valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4593
4594   if (targetm.expand_builtin_va_start)
4595     targetm.expand_builtin_va_start (valist, nextarg);
4596   else
4597     std_expand_builtin_va_start (valist, nextarg);
4598
4599   return const0_rtx;
4600 }
4601
4602 /* The "standard" implementation of va_arg: read the value from the
4603    current (padded) address and increment by the (padded) size.  */
4604
4605 tree
4606 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4607                           gimple_seq *post_p)
4608 {
4609   tree addr, t, type_size, rounded_size, valist_tmp;
4610   unsigned HOST_WIDE_INT align, boundary;
4611   bool indirect;
4612
4613 #ifdef ARGS_GROW_DOWNWARD
4614   /* All of the alignment and movement below is for args-grow-up machines.
4615      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4616      implement their own specialized gimplify_va_arg_expr routines.  */
4617   gcc_unreachable ();
4618 #endif
4619
4620   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4621   if (indirect)
4622     type = build_pointer_type (type);
4623
4624   align = PARM_BOUNDARY / BITS_PER_UNIT;
4625   boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
4626
4627   /* When we align parameter on stack for caller, if the parameter
4628      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4629      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
4630      here with caller.  */
4631   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4632     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4633
4634   boundary /= BITS_PER_UNIT;
4635
4636   /* Hoist the valist value into a temporary for the moment.  */
4637   valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4638
4639   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
4640      requires greater alignment, we must perform dynamic alignment.  */
4641   if (boundary > align
4642       && !integer_zerop (TYPE_SIZE (type)))
4643     {
4644       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4645                   fold_build2 (POINTER_PLUS_EXPR,
4646                                TREE_TYPE (valist),
4647                                valist_tmp, size_int (boundary - 1)));
4648       gimplify_and_add (t, pre_p);
4649
4650       t = fold_convert (sizetype, valist_tmp);
4651       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4652                   fold_convert (TREE_TYPE (valist),
4653                                 fold_build2 (BIT_AND_EXPR, sizetype, t,
4654                                              size_int (-boundary))));
4655       gimplify_and_add (t, pre_p);
4656     }
4657   else
4658     boundary = align;
4659
4660   /* If the actual alignment is less than the alignment of the type,
4661      adjust the type accordingly so that we don't assume strict alignment
4662      when dereferencing the pointer.  */
4663   boundary *= BITS_PER_UNIT;
4664   if (boundary < TYPE_ALIGN (type))
4665     {
4666       type = build_variant_type_copy (type);
4667       TYPE_ALIGN (type) = boundary;
4668     }
4669
4670   /* Compute the rounded size of the type.  */
4671   type_size = size_in_bytes (type);
4672   rounded_size = round_up (type_size, align);
4673
4674   /* Reduce rounded_size so it's sharable with the postqueue.  */
4675   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4676
4677   /* Get AP.  */
4678   addr = valist_tmp;
4679   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4680     {
4681       /* Small args are padded downward.  */
4682       t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4683                        rounded_size, size_int (align));
4684       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4685                        size_binop (MINUS_EXPR, rounded_size, type_size));
4686       addr = fold_build2 (POINTER_PLUS_EXPR,
4687                           TREE_TYPE (addr), addr, t);
4688     }
4689
4690   /* Compute new value for AP.  */
4691   t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist), valist_tmp, rounded_size);
4692   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4693   gimplify_and_add (t, pre_p);
4694
4695   addr = fold_convert (build_pointer_type (type), addr);
4696
4697   if (indirect)
4698     addr = build_va_arg_indirect_ref (addr);
4699
4700   return build_va_arg_indirect_ref (addr);
4701 }
4702
4703 /* Build an indirect-ref expression over the given TREE, which represents a
4704    piece of a va_arg() expansion.  */
4705 tree
4706 build_va_arg_indirect_ref (tree addr)
4707 {
4708   addr = build_fold_indirect_ref_loc (EXPR_LOCATION (addr), addr);
4709
4710   if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF.  */
4711     mf_mark (addr);
4712
4713   return addr;
4714 }
4715
4716 /* Return a dummy expression of type TYPE in order to keep going after an
4717    error.  */
4718
4719 static tree
4720 dummy_object (tree type)
4721 {
4722   tree t = build_int_cst (build_pointer_type (type), 0);
4723   return build2 (MEM_REF, type, t, t);
4724 }
4725
4726 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4727    builtin function, but a very special sort of operator.  */
4728
4729 enum gimplify_status
4730 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4731 {
4732   tree promoted_type, have_va_type;
4733   tree valist = TREE_OPERAND (*expr_p, 0);
4734   tree type = TREE_TYPE (*expr_p);
4735   tree t;
4736   location_t loc = EXPR_LOCATION (*expr_p);
4737
4738   /* Verify that valist is of the proper type.  */
4739   have_va_type = TREE_TYPE (valist);
4740   if (have_va_type == error_mark_node)
4741     return GS_ERROR;
4742   have_va_type = targetm.canonical_va_list_type (have_va_type);
4743
4744   if (have_va_type == NULL_TREE)
4745     {
4746       error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4747       return GS_ERROR;
4748     }
4749
4750   /* Generate a diagnostic for requesting data of a type that cannot
4751      be passed through `...' due to type promotion at the call site.  */
4752   if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4753            != type)
4754     {
4755       static bool gave_help;
4756       bool warned;
4757
4758       /* Unfortunately, this is merely undefined, rather than a constraint
4759          violation, so we cannot make this an error.  If this call is never
4760          executed, the program is still strictly conforming.  */
4761       warned = warning_at (loc, 0,
4762                            "%qT is promoted to %qT when passed through %<...%>",
4763                            type, promoted_type);
4764       if (!gave_help && warned)
4765         {
4766           gave_help = true;
4767           inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4768                   promoted_type, type);
4769         }
4770
4771       /* We can, however, treat "undefined" any way we please.
4772          Call abort to encourage the user to fix the program.  */
4773       if (warned)
4774         inform (loc, "if this code is reached, the program will abort");
4775       /* Before the abort, allow the evaluation of the va_list
4776          expression to exit or longjmp.  */
4777       gimplify_and_add (valist, pre_p);
4778       t = build_call_expr_loc (loc,
4779                                implicit_built_in_decls[BUILT_IN_TRAP], 0);
4780       gimplify_and_add (t, pre_p);
4781
4782       /* This is dead code, but go ahead and finish so that the
4783          mode of the result comes out right.  */
4784       *expr_p = dummy_object (type);
4785       return GS_ALL_DONE;
4786     }
4787   else
4788     {
4789       /* Make it easier for the backends by protecting the valist argument
4790          from multiple evaluations.  */
4791       if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4792         {
4793           /* For this case, the backends will be expecting a pointer to
4794              TREE_TYPE (abi), but it's possible we've
4795              actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4796              So fix it.  */
4797           if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4798             {
4799               tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4800               valist = fold_convert_loc (loc, p1,
4801                                          build_fold_addr_expr_loc (loc, valist));
4802             }
4803
4804           gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4805         }
4806       else
4807         gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4808
4809       if (!targetm.gimplify_va_arg_expr)
4810         /* FIXME: Once most targets are converted we should merely
4811            assert this is non-null.  */
4812         return GS_ALL_DONE;
4813
4814       *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4815       return GS_OK;
4816     }
4817 }
4818
4819 /* Expand EXP, a call to __builtin_va_end.  */
4820
4821 static rtx
4822 expand_builtin_va_end (tree exp)
4823 {
4824   tree valist = CALL_EXPR_ARG (exp, 0);
4825
4826   /* Evaluate for side effects, if needed.  I hate macros that don't
4827      do that.  */
4828   if (TREE_SIDE_EFFECTS (valist))
4829     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4830
4831   return const0_rtx;
4832 }
4833
4834 /* Expand EXP, a call to __builtin_va_copy.  We do this as a
4835    builtin rather than just as an assignment in stdarg.h because of the
4836    nastiness of array-type va_list types.  */
4837
4838 static rtx
4839 expand_builtin_va_copy (tree exp)
4840 {
4841   tree dst, src, t;
4842   location_t loc = EXPR_LOCATION (exp);
4843
4844   dst = CALL_EXPR_ARG (exp, 0);
4845   src = CALL_EXPR_ARG (exp, 1);
4846
4847   dst = stabilize_va_list_loc (loc, dst, 1);
4848   src = stabilize_va_list_loc (loc, src, 0);
4849
4850   gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4851
4852   if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4853     {
4854       t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4855       TREE_SIDE_EFFECTS (t) = 1;
4856       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4857     }
4858   else
4859     {
4860       rtx dstb, srcb, size;
4861
4862       /* Evaluate to pointers.  */
4863       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4864       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4865       size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4866                   NULL_RTX, VOIDmode, EXPAND_NORMAL);
4867
4868       dstb = convert_memory_address (Pmode, dstb);
4869       srcb = convert_memory_address (Pmode, srcb);
4870
4871       /* "Dereference" to BLKmode memories.  */
4872       dstb = gen_rtx_MEM (BLKmode, dstb);
4873       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4874       set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4875       srcb = gen_rtx_MEM (BLKmode, srcb);
4876       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4877       set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4878
4879       /* Copy.  */
4880       emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4881     }
4882
4883   return const0_rtx;
4884 }
4885
4886 /* Expand a call to one of the builtin functions __builtin_frame_address or
4887    __builtin_return_address.  */
4888
4889 static rtx
4890 expand_builtin_frame_address (tree fndecl, tree exp)
4891 {
4892   /* The argument must be a nonnegative integer constant.
4893      It counts the number of frames to scan up the stack.
4894      The value is the return address saved in that frame.  */
4895   if (call_expr_nargs (exp) == 0)
4896     /* Warning about missing arg was already issued.  */
4897     return const0_rtx;
4898   else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4899     {
4900       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4901         error ("invalid argument to %<__builtin_frame_address%>");
4902       else
4903         error ("invalid argument to %<__builtin_return_address%>");
4904       return const0_rtx;
4905     }
4906   else
4907     {
4908       rtx tem
4909         = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4910                                       tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4911
4912       /* Some ports cannot access arbitrary stack frames.  */
4913       if (tem == NULL)
4914         {
4915           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4916             warning (0, "unsupported argument to %<__builtin_frame_address%>");
4917           else
4918             warning (0, "unsupported argument to %<__builtin_return_address%>");
4919           return const0_rtx;
4920         }
4921
4922       /* For __builtin_frame_address, return what we've got.  */
4923       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4924         return tem;
4925
4926       if (!REG_P (tem)
4927           && ! CONSTANT_P (tem))
4928         tem = copy_to_mode_reg (Pmode, tem);
4929       return tem;
4930     }
4931 }
4932
4933 /* Expand EXP, a call to the alloca builtin.  Return NULL_RTX if we
4934    failed and the caller should emit a normal call, otherwise try to
4935    get the result in TARGET, if convenient.  CANNOT_ACCUMULATE is the
4936    same as for allocate_dynamic_stack_space.  */
4937
4938 static rtx
4939 expand_builtin_alloca (tree exp, rtx target, bool cannot_accumulate)
4940 {
4941   rtx op0;
4942   rtx result;
4943
4944   /* Emit normal call if marked not-inlineable.  */
4945   if (CALL_CANNOT_INLINE_P (exp))
4946     return NULL_RTX;
4947
4948   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4949     return NULL_RTX;
4950
4951   /* Compute the argument.  */
4952   op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4953
4954   /* Allocate the desired space.  */
4955   result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT,
4956                                          cannot_accumulate);
4957   result = convert_memory_address (ptr_mode, result);
4958
4959   return result;
4960 }
4961
4962 /* Expand a call to a bswap builtin with argument ARG0.  MODE
4963    is the mode to expand with.  */
4964
4965 static rtx
4966 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
4967 {
4968   enum machine_mode mode;
4969   tree arg;
4970   rtx op0;
4971
4972   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4973     return NULL_RTX;
4974
4975   arg = CALL_EXPR_ARG (exp, 0);
4976   mode = TYPE_MODE (TREE_TYPE (arg));
4977   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4978
4979   target = expand_unop (mode, bswap_optab, op0, target, 1);
4980
4981   gcc_assert (target);
4982
4983   return convert_to_mode (mode, target, 0);
4984 }
4985
4986 /* Expand a call to a unary builtin in EXP.
4987    Return NULL_RTX if a normal call should be emitted rather than expanding the
4988    function in-line.  If convenient, the result should be placed in TARGET.
4989    SUBTARGET may be used as the target for computing one of EXP's operands.  */
4990
4991 static rtx
4992 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
4993                      rtx subtarget, optab op_optab)
4994 {
4995   rtx op0;
4996
4997   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4998     return NULL_RTX;
4999
5000   /* Compute the argument.  */
5001   op0 = expand_expr (CALL_EXPR_ARG (exp, 0),
5002                      (subtarget
5003                       && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0)))
5004                           == GET_MODE (subtarget))) ? subtarget : NULL_RTX,
5005                      VOIDmode, EXPAND_NORMAL);
5006   /* Compute op, into TARGET if possible.
5007      Set TARGET to wherever the result comes back.  */
5008   target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
5009                         op_optab, op0, target, 1);
5010   gcc_assert (target);
5011
5012   return convert_to_mode (target_mode, target, 0);
5013 }
5014
5015 /* Expand a call to __builtin_expect.  We just return our argument
5016    as the builtin_expect semantic should've been already executed by
5017    tree branch prediction pass. */
5018
5019 static rtx
5020 expand_builtin_expect (tree exp, rtx target)
5021 {
5022   tree arg;
5023
5024   if (call_expr_nargs (exp) < 2)
5025     return const0_rtx;
5026   arg = CALL_EXPR_ARG (exp, 0);
5027
5028   target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5029   /* When guessing was done, the hints should be already stripped away.  */
5030   gcc_assert (!flag_guess_branch_prob
5031               || optimize == 0 || seen_error ());
5032   return target;
5033 }
5034
5035 void
5036 expand_builtin_trap (void)
5037 {
5038 #ifdef HAVE_trap
5039   if (HAVE_trap)
5040     emit_insn (gen_trap ());
5041   else
5042 #endif
5043     emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
5044   emit_barrier ();
5045 }
5046
5047 /* Expand a call to __builtin_unreachable.  We do nothing except emit
5048    a barrier saying that control flow will not pass here.
5049
5050    It is the responsibility of the program being compiled to ensure
5051    that control flow does never reach __builtin_unreachable.  */
5052 static void
5053 expand_builtin_unreachable (void)
5054 {
5055   emit_barrier ();
5056 }
5057
5058 /* Expand EXP, a call to fabs, fabsf or fabsl.
5059    Return NULL_RTX if a normal call should be emitted rather than expanding
5060    the function inline.  If convenient, the result should be placed
5061    in TARGET.  SUBTARGET may be used as the target for computing
5062    the operand.  */
5063
5064 static rtx
5065 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
5066 {
5067   enum machine_mode mode;
5068   tree arg;
5069   rtx op0;
5070
5071   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5072     return NULL_RTX;
5073
5074   arg = CALL_EXPR_ARG (exp, 0);
5075   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
5076   mode = TYPE_MODE (TREE_TYPE (arg));
5077   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5078   return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
5079 }
5080
5081 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5082    Return NULL is a normal call should be emitted rather than expanding the
5083    function inline.  If convenient, the result should be placed in TARGET.
5084    SUBTARGET may be used as the target for computing the operand.  */
5085
5086 static rtx
5087 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
5088 {
5089   rtx op0, op1;
5090   tree arg;
5091
5092   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
5093     return NULL_RTX;
5094
5095   arg = CALL_EXPR_ARG (exp, 0);
5096   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5097
5098   arg = CALL_EXPR_ARG (exp, 1);
5099   op1 = expand_normal (arg);
5100
5101   return expand_copysign (op0, op1, target);
5102 }
5103
5104 /* Create a new constant string literal and return a char* pointer to it.
5105    The STRING_CST value is the LEN characters at STR.  */
5106 tree
5107 build_string_literal (int len, const char *str)
5108 {
5109   tree t, elem, index, type;
5110
5111   t = build_string (len, str);
5112   elem = build_type_variant (char_type_node, 1, 0);
5113   index = build_index_type (size_int (len - 1));
5114   type = build_array_type (elem, index);
5115   TREE_TYPE (t) = type;
5116   TREE_CONSTANT (t) = 1;
5117   TREE_READONLY (t) = 1;
5118   TREE_STATIC (t) = 1;
5119
5120   type = build_pointer_type (elem);
5121   t = build1 (ADDR_EXPR, type,
5122               build4 (ARRAY_REF, elem,
5123                       t, integer_zero_node, NULL_TREE, NULL_TREE));
5124   return t;
5125 }
5126
5127 /* Expand a call to either the entry or exit function profiler.  */
5128
5129 static rtx
5130 expand_builtin_profile_func (bool exitp)
5131 {
5132   rtx this_rtx, which;
5133
5134   this_rtx = DECL_RTL (current_function_decl);
5135   gcc_assert (MEM_P (this_rtx));
5136   this_rtx = XEXP (this_rtx, 0);
5137
5138   if (exitp)
5139     which = profile_function_exit_libfunc;
5140   else
5141     which = profile_function_entry_libfunc;
5142
5143   emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this_rtx, Pmode,
5144                      expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5145                                                  0),
5146                      Pmode);
5147
5148   return const0_rtx;
5149 }
5150
5151 /* Expand a call to __builtin___clear_cache.  */
5152
5153 static rtx
5154 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
5155 {
5156 #ifndef HAVE_clear_cache
5157 #ifdef CLEAR_INSN_CACHE
5158   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5159      does something.  Just do the default expansion to a call to
5160      __clear_cache().  */
5161   return NULL_RTX;
5162 #else
5163   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5164      does nothing.  There is no need to call it.  Do nothing.  */
5165   return const0_rtx;
5166 #endif /* CLEAR_INSN_CACHE */
5167 #else
5168   /* We have a "clear_cache" insn, and it will handle everything.  */
5169   tree begin, end;
5170   rtx begin_rtx, end_rtx;
5171   enum insn_code icode;
5172
5173   /* We must not expand to a library call.  If we did, any
5174      fallback library function in libgcc that might contain a call to
5175      __builtin___clear_cache() would recurse infinitely.  */
5176   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5177     {
5178       error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5179       return const0_rtx;
5180     }
5181
5182   if (HAVE_clear_cache)
5183     {
5184       icode = CODE_FOR_clear_cache;
5185
5186       begin = CALL_EXPR_ARG (exp, 0);
5187       begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
5188       begin_rtx = convert_memory_address (Pmode, begin_rtx);
5189       if (!insn_data[icode].operand[0].predicate (begin_rtx, Pmode))
5190         begin_rtx = copy_to_mode_reg (Pmode, begin_rtx);
5191
5192       end = CALL_EXPR_ARG (exp, 1);
5193       end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
5194       end_rtx = convert_memory_address (Pmode, end_rtx);
5195       if (!insn_data[icode].operand[1].predicate (end_rtx, Pmode))
5196         end_rtx = copy_to_mode_reg (Pmode, end_rtx);
5197
5198       emit_insn (gen_clear_cache (begin_rtx, end_rtx));
5199     }
5200   return const0_rtx;
5201 #endif /* HAVE_clear_cache */
5202 }
5203
5204 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT.  */
5205
5206 static rtx
5207 round_trampoline_addr (rtx tramp)
5208 {
5209   rtx temp, addend, mask;
5210
5211   /* If we don't need too much alignment, we'll have been guaranteed
5212      proper alignment by get_trampoline_type.  */
5213   if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5214     return tramp;
5215
5216   /* Round address up to desired boundary.  */
5217   temp = gen_reg_rtx (Pmode);
5218   addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5219   mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5220
5221   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5222                                temp, 0, OPTAB_LIB_WIDEN);
5223   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5224                                temp, 0, OPTAB_LIB_WIDEN);
5225
5226   return tramp;
5227 }
5228
5229 static rtx
5230 expand_builtin_init_trampoline (tree exp)
5231 {
5232   tree t_tramp, t_func, t_chain;
5233   rtx m_tramp, r_tramp, r_chain, tmp;
5234
5235   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5236                          POINTER_TYPE, VOID_TYPE))
5237     return NULL_RTX;
5238
5239   t_tramp = CALL_EXPR_ARG (exp, 0);
5240   t_func = CALL_EXPR_ARG (exp, 1);
5241   t_chain = CALL_EXPR_ARG (exp, 2);
5242
5243   r_tramp = expand_normal (t_tramp);
5244   m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
5245   MEM_NOTRAP_P (m_tramp) = 1;
5246
5247   /* The TRAMP argument should be the address of a field within the
5248      local function's FRAME decl.  Let's see if we can fill in the
5249      to fill in the MEM_ATTRs for this memory.  */
5250   if (TREE_CODE (t_tramp) == ADDR_EXPR)
5251     set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
5252                                      true, 0);
5253
5254   tmp = round_trampoline_addr (r_tramp);
5255   if (tmp != r_tramp)
5256     {
5257       m_tramp = change_address (m_tramp, BLKmode, tmp);
5258       set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
5259       set_mem_size (m_tramp, GEN_INT (TRAMPOLINE_SIZE));
5260     }
5261
5262   /* The FUNC argument should be the address of the nested function.
5263      Extract the actual function decl to pass to the hook.  */
5264   gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
5265   t_func = TREE_OPERAND (t_func, 0);
5266   gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
5267
5268   r_chain = expand_normal (t_chain);
5269
5270   /* Generate insns to initialize the trampoline.  */
5271   targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
5272
5273   trampolines_created = 1;
5274
5275   warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
5276               "trampoline generated for nested function %qD", t_func);
5277
5278   return const0_rtx;
5279 }
5280
5281 static rtx
5282 expand_builtin_adjust_trampoline (tree exp)
5283 {
5284   rtx tramp;
5285
5286   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5287     return NULL_RTX;
5288
5289   tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5290   tramp = round_trampoline_addr (tramp);
5291   if (targetm.calls.trampoline_adjust_address)
5292     tramp = targetm.calls.trampoline_adjust_address (tramp);
5293
5294   return tramp;
5295 }
5296
5297 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5298    function.  The function first checks whether the back end provides
5299    an insn to implement signbit for the respective mode.  If not, it
5300    checks whether the floating point format of the value is such that
5301    the sign bit can be extracted.  If that is not the case, the
5302    function returns NULL_RTX to indicate that a normal call should be
5303    emitted rather than expanding the function in-line.  EXP is the
5304    expression that is a call to the builtin function; if convenient,
5305    the result should be placed in TARGET.  */
5306 static rtx
5307 expand_builtin_signbit (tree exp, rtx target)
5308 {
5309   const struct real_format *fmt;
5310   enum machine_mode fmode, imode, rmode;
5311   tree arg;
5312   int word, bitpos;
5313   enum insn_code icode;
5314   rtx temp;
5315   location_t loc = EXPR_LOCATION (exp);
5316
5317   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5318     return NULL_RTX;
5319
5320   arg = CALL_EXPR_ARG (exp, 0);
5321   fmode = TYPE_MODE (TREE_TYPE (arg));
5322   rmode = TYPE_MODE (TREE_TYPE (exp));
5323   fmt = REAL_MODE_FORMAT (fmode);
5324
5325   arg = builtin_save_expr (arg);
5326
5327   /* Expand the argument yielding a RTX expression. */
5328   temp = expand_normal (arg);
5329
5330   /* Check if the back end provides an insn that handles signbit for the
5331      argument's mode. */
5332   icode = optab_handler (signbit_optab, fmode);
5333   if (icode != CODE_FOR_nothing)
5334     {
5335       rtx last = get_last_insn ();
5336       target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5337       if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
5338         return target;
5339       delete_insns_since (last);
5340     }
5341
5342   /* For floating point formats without a sign bit, implement signbit
5343      as "ARG < 0.0".  */
5344   bitpos = fmt->signbit_ro;
5345   if (bitpos < 0)
5346   {
5347     /* But we can't do this if the format supports signed zero.  */
5348     if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5349       return NULL_RTX;
5350
5351     arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5352                        build_real (TREE_TYPE (arg), dconst0));
5353     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5354   }
5355
5356   if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5357     {
5358       imode = int_mode_for_mode (fmode);
5359       if (imode == BLKmode)
5360         return NULL_RTX;
5361       temp = gen_lowpart (imode, temp);
5362     }
5363   else
5364     {
5365       imode = word_mode;
5366       /* Handle targets with different FP word orders.  */
5367       if (FLOAT_WORDS_BIG_ENDIAN)
5368         word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5369       else
5370         word = bitpos / BITS_PER_WORD;
5371       temp = operand_subword_force (temp, word, fmode);
5372       bitpos = bitpos % BITS_PER_WORD;
5373     }
5374
5375   /* Force the intermediate word_mode (or narrower) result into a
5376      register.  This avoids attempting to create paradoxical SUBREGs
5377      of floating point modes below.  */
5378   temp = force_reg (imode, temp);
5379
5380   /* If the bitpos is within the "result mode" lowpart, the operation
5381      can be implement with a single bitwise AND.  Otherwise, we need
5382      a right shift and an AND.  */
5383
5384   if (bitpos < GET_MODE_BITSIZE (rmode))
5385     {
5386       double_int mask = double_int_setbit (double_int_zero, bitpos);
5387
5388       if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5389         temp = gen_lowpart (rmode, temp);
5390       temp = expand_binop (rmode, and_optab, temp,
5391                            immed_double_int_const (mask, rmode),
5392                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5393     }
5394   else
5395     {
5396       /* Perform a logical right shift to place the signbit in the least
5397          significant bit, then truncate the result to the desired mode
5398          and mask just this bit.  */
5399       temp = expand_shift (RSHIFT_EXPR, imode, temp,
5400                            build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5401       temp = gen_lowpart (rmode, temp);
5402       temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5403                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5404     }
5405
5406   return temp;
5407 }
5408
5409 /* Expand fork or exec calls.  TARGET is the desired target of the
5410    call.  EXP is the call. FN is the
5411    identificator of the actual function.  IGNORE is nonzero if the
5412    value is to be ignored.  */
5413
5414 static rtx
5415 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5416 {
5417   tree id, decl;
5418   tree call;
5419
5420   /* If we are not profiling, just call the function.  */
5421   if (!profile_arc_flag)
5422     return NULL_RTX;
5423
5424   /* Otherwise call the wrapper.  This should be equivalent for the rest of
5425      compiler, so the code does not diverge, and the wrapper may run the
5426      code necessary for keeping the profiling sane.  */
5427
5428   switch (DECL_FUNCTION_CODE (fn))
5429     {
5430     case BUILT_IN_FORK:
5431       id = get_identifier ("__gcov_fork");
5432       break;
5433
5434     case BUILT_IN_EXECL:
5435       id = get_identifier ("__gcov_execl");
5436       break;
5437
5438     case BUILT_IN_EXECV:
5439       id = get_identifier ("__gcov_execv");
5440       break;
5441
5442     case BUILT_IN_EXECLP:
5443       id = get_identifier ("__gcov_execlp");
5444       break;
5445
5446     case BUILT_IN_EXECLE:
5447       id = get_identifier ("__gcov_execle");
5448       break;
5449
5450     case BUILT_IN_EXECVP:
5451       id = get_identifier ("__gcov_execvp");
5452       break;
5453
5454     case BUILT_IN_EXECVE:
5455       id = get_identifier ("__gcov_execve");
5456       break;
5457
5458     default:
5459       gcc_unreachable ();
5460     }
5461
5462   decl = build_decl (DECL_SOURCE_LOCATION (fn),
5463                      FUNCTION_DECL, id, TREE_TYPE (fn));
5464   DECL_EXTERNAL (decl) = 1;
5465   TREE_PUBLIC (decl) = 1;
5466   DECL_ARTIFICIAL (decl) = 1;
5467   TREE_NOTHROW (decl) = 1;
5468   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5469   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5470   call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5471   return expand_call (call, target, ignore);
5472  }
5473
5474
5475 \f
5476 /* Reconstitute a mode for a __sync intrinsic operation.  Since the type of
5477    the pointer in these functions is void*, the tree optimizers may remove
5478    casts.  The mode computed in expand_builtin isn't reliable either, due
5479    to __sync_bool_compare_and_swap.
5480
5481    FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5482    group of builtins.  This gives us log2 of the mode size.  */
5483
5484 static inline enum machine_mode
5485 get_builtin_sync_mode (int fcode_diff)
5486 {
5487   /* The size is not negotiable, so ask not to get BLKmode in return
5488      if the target indicates that a smaller size would be better.  */
5489   return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5490 }
5491
5492 /* Expand the memory expression LOC and return the appropriate memory operand
5493    for the builtin_sync operations.  */
5494
5495 static rtx
5496 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5497 {
5498   rtx addr, mem;
5499
5500   addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
5501   addr = convert_memory_address (Pmode, addr);
5502
5503   /* Note that we explicitly do not want any alias information for this
5504      memory, so that we kill all other live memories.  Otherwise we don't
5505      satisfy the full barrier semantics of the intrinsic.  */
5506   mem = validize_mem (gen_rtx_MEM (mode, addr));
5507
5508   /* The alignment needs to be at least according to that of the mode.  */
5509   set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
5510                            get_pointer_alignment (loc, BIGGEST_ALIGNMENT)));
5511   set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5512   MEM_VOLATILE_P (mem) = 1;
5513
5514   return mem;
5515 }
5516
5517 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5518    EXP is the CALL_EXPR.  CODE is the rtx code
5519    that corresponds to the arithmetic or logical operation from the name;
5520    an exception here is that NOT actually means NAND.  TARGET is an optional
5521    place for us to store the results; AFTER is true if this is the
5522    fetch_and_xxx form.  IGNORE is true if we don't actually care about
5523    the result of the operation at all.  */
5524
5525 static rtx
5526 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5527                                enum rtx_code code, bool after,
5528                                rtx target, bool ignore)
5529 {
5530   rtx val, mem;
5531   enum machine_mode old_mode;
5532   location_t loc = EXPR_LOCATION (exp);
5533
5534   if (code == NOT && warn_sync_nand)
5535     {
5536       tree fndecl = get_callee_fndecl (exp);
5537       enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5538
5539       static bool warned_f_a_n, warned_n_a_f;
5540
5541       switch (fcode)
5542         {
5543         case BUILT_IN_FETCH_AND_NAND_1:
5544         case BUILT_IN_FETCH_AND_NAND_2:
5545         case BUILT_IN_FETCH_AND_NAND_4:
5546         case BUILT_IN_FETCH_AND_NAND_8:
5547         case BUILT_IN_FETCH_AND_NAND_16:
5548
5549           if (warned_f_a_n)
5550             break;
5551
5552           fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
5553           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5554           warned_f_a_n = true;
5555           break;
5556
5557         case BUILT_IN_NAND_AND_FETCH_1:
5558         case BUILT_IN_NAND_AND_FETCH_2:
5559         case BUILT_IN_NAND_AND_FETCH_4:
5560         case BUILT_IN_NAND_AND_FETCH_8:
5561         case BUILT_IN_NAND_AND_FETCH_16:
5562
5563           if (warned_n_a_f)
5564             break;
5565
5566           fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
5567           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5568           warned_n_a_f = true;
5569           break;
5570
5571         default:
5572           gcc_unreachable ();
5573         }
5574     }
5575
5576   /* Expand the operands.  */
5577   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5578
5579   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5580   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5581      of CONST_INTs, where we know the old_mode only from the call argument.  */
5582   old_mode = GET_MODE (val);
5583   if (old_mode == VOIDmode)
5584     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5585   val = convert_modes (mode, old_mode, val, 1);
5586
5587   if (ignore)
5588     return expand_sync_operation (mem, val, code);
5589   else
5590     return expand_sync_fetch_operation (mem, val, code, after, target);
5591 }
5592
5593 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5594    intrinsics. EXP is the CALL_EXPR.  IS_BOOL is
5595    true if this is the boolean form.  TARGET is a place for us to store the
5596    results; this is NOT optional if IS_BOOL is true.  */
5597
5598 static rtx
5599 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5600                                  bool is_bool, rtx target)
5601 {
5602   rtx old_val, new_val, mem;
5603   enum machine_mode old_mode;
5604
5605   /* Expand the operands.  */
5606   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5607
5608
5609   old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX,
5610                          mode, EXPAND_NORMAL);
5611   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5612      of CONST_INTs, where we know the old_mode only from the call argument.  */
5613   old_mode = GET_MODE (old_val);
5614   if (old_mode == VOIDmode)
5615     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5616   old_val = convert_modes (mode, old_mode, old_val, 1);
5617
5618   new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL_RTX,
5619                          mode, EXPAND_NORMAL);
5620   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5621      of CONST_INTs, where we know the old_mode only from the call argument.  */
5622   old_mode = GET_MODE (new_val);
5623   if (old_mode == VOIDmode)
5624     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2)));
5625   new_val = convert_modes (mode, old_mode, new_val, 1);
5626
5627   if (is_bool)
5628     return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5629   else
5630     return expand_val_compare_and_swap (mem, old_val, new_val, target);
5631 }
5632
5633 /* Expand the __sync_lock_test_and_set intrinsic.  Note that the most
5634    general form is actually an atomic exchange, and some targets only
5635    support a reduced form with the second argument being a constant 1.
5636    EXP is the CALL_EXPR; TARGET is an optional place for us to store
5637    the results.  */
5638
5639 static rtx
5640 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
5641                                   rtx target)
5642 {
5643   rtx val, mem;
5644   enum machine_mode old_mode;
5645
5646   /* Expand the operands.  */
5647   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5648   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5649   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5650      of CONST_INTs, where we know the old_mode only from the call argument.  */
5651   old_mode = GET_MODE (val);
5652   if (old_mode == VOIDmode)
5653     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5654   val = convert_modes (mode, old_mode, val, 1);
5655
5656   return expand_sync_lock_test_and_set (mem, val, target);
5657 }
5658
5659 /* Expand the __sync_synchronize intrinsic.  */
5660
5661 static void
5662 expand_builtin_synchronize (void)
5663 {
5664   gimple x;
5665   VEC (tree, gc) *v_clobbers;
5666
5667 #ifdef HAVE_memory_barrier
5668   if (HAVE_memory_barrier)
5669     {
5670       emit_insn (gen_memory_barrier ());
5671       return;
5672     }
5673 #endif
5674
5675   if (synchronize_libfunc != NULL_RTX)
5676     {
5677       emit_library_call (synchronize_libfunc, LCT_NORMAL, VOIDmode, 0);
5678       return;
5679     }
5680
5681   /* If no explicit memory barrier instruction is available, create an
5682      empty asm stmt with a memory clobber.  */
5683   v_clobbers = VEC_alloc (tree, gc, 1);
5684   VEC_quick_push (tree, v_clobbers,
5685                   tree_cons (NULL, build_string (6, "memory"), NULL));
5686   x = gimple_build_asm_vec ("", NULL, NULL, v_clobbers, NULL);
5687   gimple_asm_set_volatile (x, true);
5688   expand_asm_stmt (x);
5689 }
5690
5691 /* Expand the __sync_lock_release intrinsic.  EXP is the CALL_EXPR.  */
5692
5693 static void
5694 expand_builtin_lock_release (enum machine_mode mode, tree exp)
5695 {
5696   enum insn_code icode;
5697   rtx mem, insn;
5698   rtx val = const0_rtx;
5699
5700   /* Expand the operands.  */
5701   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5702
5703   /* If there is an explicit operation in the md file, use it.  */
5704   icode = direct_optab_handler (sync_lock_release_optab, mode);
5705   if (icode != CODE_FOR_nothing)
5706     {
5707       if (!insn_data[icode].operand[1].predicate (val, mode))
5708         val = force_reg (mode, val);
5709
5710       insn = GEN_FCN (icode) (mem, val);
5711       if (insn)
5712         {
5713           emit_insn (insn);
5714           return;
5715         }
5716     }
5717
5718   /* Otherwise we can implement this operation by emitting a barrier
5719      followed by a store of zero.  */
5720   expand_builtin_synchronize ();
5721   emit_move_insn (mem, val);
5722 }
5723 \f
5724 /* Expand an expression EXP that calls a built-in function,
5725    with result going to TARGET if that's convenient
5726    (and in mode MODE if that's convenient).
5727    SUBTARGET may be used as the target for computing one of EXP's operands.
5728    IGNORE is nonzero if the value is to be ignored.  */
5729
5730 rtx
5731 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5732                 int ignore)
5733 {
5734   tree fndecl = get_callee_fndecl (exp);
5735   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5736   enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5737   int flags;
5738
5739   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5740     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5741
5742   /* When not optimizing, generate calls to library functions for a certain
5743      set of builtins.  */
5744   if (!optimize
5745       && !called_as_built_in (fndecl)
5746       && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5747       && fcode != BUILT_IN_ALLOCA
5748       && fcode != BUILT_IN_FREE)
5749     return expand_call (exp, target, ignore);
5750
5751   /* The built-in function expanders test for target == const0_rtx
5752      to determine whether the function's result will be ignored.  */
5753   if (ignore)
5754     target = const0_rtx;
5755
5756   /* If the result of a pure or const built-in function is ignored, and
5757      none of its arguments are volatile, we can avoid expanding the
5758      built-in call and just evaluate the arguments for side-effects.  */
5759   if (target == const0_rtx
5760       && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5761       && !(flags & ECF_LOOPING_CONST_OR_PURE))
5762     {
5763       bool volatilep = false;
5764       tree arg;
5765       call_expr_arg_iterator iter;
5766
5767       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5768         if (TREE_THIS_VOLATILE (arg))
5769           {
5770             volatilep = true;
5771             break;
5772           }
5773
5774       if (! volatilep)
5775         {
5776           FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5777             expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5778           return const0_rtx;
5779         }
5780     }
5781
5782   switch (fcode)
5783     {
5784     CASE_FLT_FN (BUILT_IN_FABS):
5785       target = expand_builtin_fabs (exp, target, subtarget);
5786       if (target)
5787         return target;
5788       break;
5789
5790     CASE_FLT_FN (BUILT_IN_COPYSIGN):
5791       target = expand_builtin_copysign (exp, target, subtarget);
5792       if (target)
5793         return target;
5794       break;
5795
5796       /* Just do a normal library call if we were unable to fold
5797          the values.  */
5798     CASE_FLT_FN (BUILT_IN_CABS):
5799       break;
5800
5801     CASE_FLT_FN (BUILT_IN_EXP):
5802     CASE_FLT_FN (BUILT_IN_EXP10):
5803     CASE_FLT_FN (BUILT_IN_POW10):
5804     CASE_FLT_FN (BUILT_IN_EXP2):
5805     CASE_FLT_FN (BUILT_IN_EXPM1):
5806     CASE_FLT_FN (BUILT_IN_LOGB):
5807     CASE_FLT_FN (BUILT_IN_LOG):
5808     CASE_FLT_FN (BUILT_IN_LOG10):
5809     CASE_FLT_FN (BUILT_IN_LOG2):
5810     CASE_FLT_FN (BUILT_IN_LOG1P):
5811     CASE_FLT_FN (BUILT_IN_TAN):
5812     CASE_FLT_FN (BUILT_IN_ASIN):
5813     CASE_FLT_FN (BUILT_IN_ACOS):
5814     CASE_FLT_FN (BUILT_IN_ATAN):
5815     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5816       /* Treat these like sqrt only if unsafe math optimizations are allowed,
5817          because of possible accuracy problems.  */
5818       if (! flag_unsafe_math_optimizations)
5819         break;
5820     CASE_FLT_FN (BUILT_IN_SQRT):
5821     CASE_FLT_FN (BUILT_IN_FLOOR):
5822     CASE_FLT_FN (BUILT_IN_CEIL):
5823     CASE_FLT_FN (BUILT_IN_TRUNC):
5824     CASE_FLT_FN (BUILT_IN_ROUND):
5825     CASE_FLT_FN (BUILT_IN_NEARBYINT):
5826     CASE_FLT_FN (BUILT_IN_RINT):
5827       target = expand_builtin_mathfn (exp, target, subtarget);
5828       if (target)
5829         return target;
5830       break;
5831
5832     CASE_FLT_FN (BUILT_IN_ILOGB):
5833       if (! flag_unsafe_math_optimizations)
5834         break;
5835     CASE_FLT_FN (BUILT_IN_ISINF):
5836     CASE_FLT_FN (BUILT_IN_FINITE):
5837     case BUILT_IN_ISFINITE:
5838     case BUILT_IN_ISNORMAL:
5839       target = expand_builtin_interclass_mathfn (exp, target);
5840       if (target)
5841         return target;
5842       break;
5843
5844     CASE_FLT_FN (BUILT_IN_LCEIL):
5845     CASE_FLT_FN (BUILT_IN_LLCEIL):
5846     CASE_FLT_FN (BUILT_IN_LFLOOR):
5847     CASE_FLT_FN (BUILT_IN_LLFLOOR):
5848       target = expand_builtin_int_roundingfn (exp, target);
5849       if (target)
5850         return target;
5851       break;
5852
5853     CASE_FLT_FN (BUILT_IN_LRINT):
5854     CASE_FLT_FN (BUILT_IN_LLRINT):
5855     CASE_FLT_FN (BUILT_IN_LROUND):
5856     CASE_FLT_FN (BUILT_IN_LLROUND):
5857       target = expand_builtin_int_roundingfn_2 (exp, target);
5858       if (target)
5859         return target;
5860       break;
5861
5862     CASE_FLT_FN (BUILT_IN_POW):
5863       target = expand_builtin_pow (exp, target, subtarget);
5864       if (target)
5865         return target;
5866       break;
5867
5868     CASE_FLT_FN (BUILT_IN_POWI):
5869       target = expand_builtin_powi (exp, target);
5870       if (target)
5871         return target;
5872       break;
5873
5874     CASE_FLT_FN (BUILT_IN_ATAN2):
5875     CASE_FLT_FN (BUILT_IN_LDEXP):
5876     CASE_FLT_FN (BUILT_IN_SCALB):
5877     CASE_FLT_FN (BUILT_IN_SCALBN):
5878     CASE_FLT_FN (BUILT_IN_SCALBLN):
5879       if (! flag_unsafe_math_optimizations)
5880         break;
5881
5882     CASE_FLT_FN (BUILT_IN_FMOD):
5883     CASE_FLT_FN (BUILT_IN_REMAINDER):
5884     CASE_FLT_FN (BUILT_IN_DREM):
5885       target = expand_builtin_mathfn_2 (exp, target, subtarget);
5886       if (target)
5887         return target;
5888       break;
5889
5890     CASE_FLT_FN (BUILT_IN_CEXPI):
5891       target = expand_builtin_cexpi (exp, target);
5892       gcc_assert (target);
5893       return target;
5894
5895     CASE_FLT_FN (BUILT_IN_SIN):
5896     CASE_FLT_FN (BUILT_IN_COS):
5897       if (! flag_unsafe_math_optimizations)
5898         break;
5899       target = expand_builtin_mathfn_3 (exp, target, subtarget);
5900       if (target)
5901         return target;
5902       break;
5903
5904     CASE_FLT_FN (BUILT_IN_SINCOS):
5905       if (! flag_unsafe_math_optimizations)
5906         break;
5907       target = expand_builtin_sincos (exp);
5908       if (target)
5909         return target;
5910       break;
5911
5912     case BUILT_IN_APPLY_ARGS:
5913       return expand_builtin_apply_args ();
5914
5915       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5916          FUNCTION with a copy of the parameters described by
5917          ARGUMENTS, and ARGSIZE.  It returns a block of memory
5918          allocated on the stack into which is stored all the registers
5919          that might possibly be used for returning the result of a
5920          function.  ARGUMENTS is the value returned by
5921          __builtin_apply_args.  ARGSIZE is the number of bytes of
5922          arguments that must be copied.  ??? How should this value be
5923          computed?  We'll also need a safe worst case value for varargs
5924          functions.  */
5925     case BUILT_IN_APPLY:
5926       if (!validate_arglist (exp, POINTER_TYPE,
5927                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5928           && !validate_arglist (exp, REFERENCE_TYPE,
5929                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5930         return const0_rtx;
5931       else
5932         {
5933           rtx ops[3];
5934
5935           ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
5936           ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
5937           ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
5938
5939           return expand_builtin_apply (ops[0], ops[1], ops[2]);
5940         }
5941
5942       /* __builtin_return (RESULT) causes the function to return the
5943          value described by RESULT.  RESULT is address of the block of
5944          memory returned by __builtin_apply.  */
5945     case BUILT_IN_RETURN:
5946       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5947         expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
5948       return const0_rtx;
5949
5950     case BUILT_IN_SAVEREGS:
5951       return expand_builtin_saveregs ();
5952
5953     case BUILT_IN_VA_ARG_PACK:
5954       /* All valid uses of __builtin_va_arg_pack () are removed during
5955          inlining.  */
5956       error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
5957       return const0_rtx;
5958
5959     case BUILT_IN_VA_ARG_PACK_LEN:
5960       /* All valid uses of __builtin_va_arg_pack_len () are removed during
5961          inlining.  */
5962       error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
5963       return const0_rtx;
5964
5965       /* Return the address of the first anonymous stack arg.  */
5966     case BUILT_IN_NEXT_ARG:
5967       if (fold_builtin_next_arg (exp, false))
5968         return const0_rtx;
5969       return expand_builtin_next_arg ();
5970
5971     case BUILT_IN_CLEAR_CACHE:
5972       target = expand_builtin___clear_cache (exp);
5973       if (target)
5974         return target;
5975       break;
5976
5977     case BUILT_IN_CLASSIFY_TYPE:
5978       return expand_builtin_classify_type (exp);
5979
5980     case BUILT_IN_CONSTANT_P:
5981       return const0_rtx;
5982
5983     case BUILT_IN_FRAME_ADDRESS:
5984     case BUILT_IN_RETURN_ADDRESS:
5985       return expand_builtin_frame_address (fndecl, exp);
5986
5987     /* Returns the address of the area where the structure is returned.
5988        0 otherwise.  */
5989     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
5990       if (call_expr_nargs (exp) != 0
5991           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
5992           || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
5993         return const0_rtx;
5994       else
5995         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
5996
5997     case BUILT_IN_ALLOCA:
5998       /* If the allocation stems from the declaration of a variable-sized
5999          object, it cannot accumulate.  */
6000       target = expand_builtin_alloca (exp, target, ALLOCA_FOR_VAR_P (exp));
6001       if (target)
6002         return target;
6003       break;
6004
6005     case BUILT_IN_STACK_SAVE:
6006       return expand_stack_save ();
6007
6008     case BUILT_IN_STACK_RESTORE:
6009       expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6010       return const0_rtx;
6011
6012     case BUILT_IN_BSWAP32:
6013     case BUILT_IN_BSWAP64:
6014       target = expand_builtin_bswap (exp, target, subtarget);
6015
6016       if (target)
6017         return target;
6018       break;
6019
6020     CASE_INT_FN (BUILT_IN_FFS):
6021     case BUILT_IN_FFSIMAX:
6022       target = expand_builtin_unop (target_mode, exp, target,
6023                                     subtarget, ffs_optab);
6024       if (target)
6025         return target;
6026       break;
6027
6028     CASE_INT_FN (BUILT_IN_CLZ):
6029     case BUILT_IN_CLZIMAX:
6030       target = expand_builtin_unop (target_mode, exp, target,
6031                                     subtarget, clz_optab);
6032       if (target)
6033         return target;
6034       break;
6035
6036     CASE_INT_FN (BUILT_IN_CTZ):
6037     case BUILT_IN_CTZIMAX:
6038       target = expand_builtin_unop (target_mode, exp, target,
6039                                     subtarget, ctz_optab);
6040       if (target)
6041         return target;
6042       break;
6043
6044     CASE_INT_FN (BUILT_IN_POPCOUNT):
6045     case BUILT_IN_POPCOUNTIMAX:
6046       target = expand_builtin_unop (target_mode, exp, target,
6047                                     subtarget, popcount_optab);
6048       if (target)
6049         return target;
6050       break;
6051
6052     CASE_INT_FN (BUILT_IN_PARITY):
6053     case BUILT_IN_PARITYIMAX:
6054       target = expand_builtin_unop (target_mode, exp, target,
6055                                     subtarget, parity_optab);
6056       if (target)
6057         return target;
6058       break;
6059
6060     case BUILT_IN_STRLEN:
6061       target = expand_builtin_strlen (exp, target, target_mode);
6062       if (target)
6063         return target;
6064       break;
6065
6066     case BUILT_IN_STRCPY:
6067       target = expand_builtin_strcpy (exp, target);
6068       if (target)
6069         return target;
6070       break;
6071
6072     case BUILT_IN_STRNCPY:
6073       target = expand_builtin_strncpy (exp, target);
6074       if (target)
6075         return target;
6076       break;
6077
6078     case BUILT_IN_STPCPY:
6079       target = expand_builtin_stpcpy (exp, target, mode);
6080       if (target)
6081         return target;
6082       break;
6083
6084     case BUILT_IN_MEMCPY:
6085       target = expand_builtin_memcpy (exp, target);
6086       if (target)
6087         return target;
6088       break;
6089
6090     case BUILT_IN_MEMPCPY:
6091       target = expand_builtin_mempcpy (exp, target, mode);
6092       if (target)
6093         return target;
6094       break;
6095
6096     case BUILT_IN_MEMSET:
6097       target = expand_builtin_memset (exp, target, mode);
6098       if (target)
6099         return target;
6100       break;
6101
6102     case BUILT_IN_BZERO:
6103       target = expand_builtin_bzero (exp);
6104       if (target)
6105         return target;
6106       break;
6107
6108     case BUILT_IN_STRCMP:
6109       target = expand_builtin_strcmp (exp, target);
6110       if (target)
6111         return target;
6112       break;
6113
6114     case BUILT_IN_STRNCMP:
6115       target = expand_builtin_strncmp (exp, target, mode);
6116       if (target)
6117         return target;
6118       break;
6119
6120     case BUILT_IN_BCMP:
6121     case BUILT_IN_MEMCMP:
6122       target = expand_builtin_memcmp (exp, target, mode);
6123       if (target)
6124         return target;
6125       break;
6126
6127     case BUILT_IN_SETJMP:
6128       /* This should have been lowered to the builtins below.  */
6129       gcc_unreachable ();
6130
6131     case BUILT_IN_SETJMP_SETUP:
6132       /* __builtin_setjmp_setup is passed a pointer to an array of five words
6133           and the receiver label.  */
6134       if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6135         {
6136           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6137                                       VOIDmode, EXPAND_NORMAL);
6138           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6139           rtx label_r = label_rtx (label);
6140
6141           /* This is copied from the handling of non-local gotos.  */
6142           expand_builtin_setjmp_setup (buf_addr, label_r);
6143           nonlocal_goto_handler_labels
6144             = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6145                                  nonlocal_goto_handler_labels);
6146           /* ??? Do not let expand_label treat us as such since we would
6147              not want to be both on the list of non-local labels and on
6148              the list of forced labels.  */
6149           FORCED_LABEL (label) = 0;
6150           return const0_rtx;
6151         }
6152       break;
6153
6154     case BUILT_IN_SETJMP_DISPATCHER:
6155        /* __builtin_setjmp_dispatcher is passed the dispatcher label.  */
6156       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6157         {
6158           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6159           rtx label_r = label_rtx (label);
6160
6161           /* Remove the dispatcher label from the list of non-local labels
6162              since the receiver labels have been added to it above.  */
6163           remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6164           return const0_rtx;
6165         }
6166       break;
6167
6168     case BUILT_IN_SETJMP_RECEIVER:
6169        /* __builtin_setjmp_receiver is passed the receiver label.  */
6170       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6171         {
6172           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6173           rtx label_r = label_rtx (label);
6174
6175           expand_builtin_setjmp_receiver (label_r);
6176           return const0_rtx;
6177         }
6178       break;
6179
6180       /* __builtin_longjmp is passed a pointer to an array of five words.
6181          It's similar to the C library longjmp function but works with
6182          __builtin_setjmp above.  */
6183     case BUILT_IN_LONGJMP:
6184       if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6185         {
6186           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6187                                       VOIDmode, EXPAND_NORMAL);
6188           rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6189
6190           if (value != const1_rtx)
6191             {
6192               error ("%<__builtin_longjmp%> second argument must be 1");
6193               return const0_rtx;
6194             }
6195
6196           expand_builtin_longjmp (buf_addr, value);
6197           return const0_rtx;
6198         }
6199       break;
6200
6201     case BUILT_IN_NONLOCAL_GOTO:
6202       target = expand_builtin_nonlocal_goto (exp);
6203       if (target)
6204         return target;
6205       break;
6206
6207       /* This updates the setjmp buffer that is its argument with the value
6208          of the current stack pointer.  */
6209     case BUILT_IN_UPDATE_SETJMP_BUF:
6210       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6211         {
6212           rtx buf_addr
6213             = expand_normal (CALL_EXPR_ARG (exp, 0));
6214
6215           expand_builtin_update_setjmp_buf (buf_addr);
6216           return const0_rtx;
6217         }
6218       break;
6219
6220     case BUILT_IN_TRAP:
6221       expand_builtin_trap ();
6222       return const0_rtx;
6223
6224     case BUILT_IN_UNREACHABLE:
6225       expand_builtin_unreachable ();
6226       return const0_rtx;
6227
6228     CASE_FLT_FN (BUILT_IN_SIGNBIT):
6229     case BUILT_IN_SIGNBITD32:
6230     case BUILT_IN_SIGNBITD64:
6231     case BUILT_IN_SIGNBITD128:
6232       target = expand_builtin_signbit (exp, target);
6233       if (target)
6234         return target;
6235       break;
6236
6237       /* Various hooks for the DWARF 2 __throw routine.  */
6238     case BUILT_IN_UNWIND_INIT:
6239       expand_builtin_unwind_init ();
6240       return const0_rtx;
6241     case BUILT_IN_DWARF_CFA:
6242       return virtual_cfa_rtx;
6243 #ifdef DWARF2_UNWIND_INFO
6244     case BUILT_IN_DWARF_SP_COLUMN:
6245       return expand_builtin_dwarf_sp_column ();
6246     case BUILT_IN_INIT_DWARF_REG_SIZES:
6247       expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6248       return const0_rtx;
6249 #endif
6250     case BUILT_IN_FROB_RETURN_ADDR:
6251       return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6252     case BUILT_IN_EXTRACT_RETURN_ADDR:
6253       return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6254     case BUILT_IN_EH_RETURN:
6255       expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6256                                 CALL_EXPR_ARG (exp, 1));
6257       return const0_rtx;
6258 #ifdef EH_RETURN_DATA_REGNO
6259     case BUILT_IN_EH_RETURN_DATA_REGNO:
6260       return expand_builtin_eh_return_data_regno (exp);
6261 #endif
6262     case BUILT_IN_EXTEND_POINTER:
6263       return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6264     case BUILT_IN_EH_POINTER:
6265       return expand_builtin_eh_pointer (exp);
6266     case BUILT_IN_EH_FILTER:
6267       return expand_builtin_eh_filter (exp);
6268     case BUILT_IN_EH_COPY_VALUES:
6269       return expand_builtin_eh_copy_values (exp);
6270
6271     case BUILT_IN_VA_START:
6272       return expand_builtin_va_start (exp);
6273     case BUILT_IN_VA_END:
6274       return expand_builtin_va_end (exp);
6275     case BUILT_IN_VA_COPY:
6276       return expand_builtin_va_copy (exp);
6277     case BUILT_IN_EXPECT:
6278       return expand_builtin_expect (exp, target);
6279     case BUILT_IN_PREFETCH:
6280       expand_builtin_prefetch (exp);
6281       return const0_rtx;
6282
6283     case BUILT_IN_PROFILE_FUNC_ENTER:
6284       return expand_builtin_profile_func (false);
6285     case BUILT_IN_PROFILE_FUNC_EXIT:
6286       return expand_builtin_profile_func (true);
6287
6288     case BUILT_IN_INIT_TRAMPOLINE:
6289       return expand_builtin_init_trampoline (exp);
6290     case BUILT_IN_ADJUST_TRAMPOLINE:
6291       return expand_builtin_adjust_trampoline (exp);
6292
6293     case BUILT_IN_FORK:
6294     case BUILT_IN_EXECL:
6295     case BUILT_IN_EXECV:
6296     case BUILT_IN_EXECLP:
6297     case BUILT_IN_EXECLE:
6298     case BUILT_IN_EXECVP:
6299     case BUILT_IN_EXECVE:
6300       target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6301       if (target)
6302         return target;
6303       break;
6304
6305     case BUILT_IN_FETCH_AND_ADD_1:
6306     case BUILT_IN_FETCH_AND_ADD_2:
6307     case BUILT_IN_FETCH_AND_ADD_4:
6308     case BUILT_IN_FETCH_AND_ADD_8:
6309     case BUILT_IN_FETCH_AND_ADD_16:
6310       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6311       target = expand_builtin_sync_operation (mode, exp, PLUS,
6312                                               false, target, ignore);
6313       if (target)
6314         return target;
6315       break;
6316
6317     case BUILT_IN_FETCH_AND_SUB_1:
6318     case BUILT_IN_FETCH_AND_SUB_2:
6319     case BUILT_IN_FETCH_AND_SUB_4:
6320     case BUILT_IN_FETCH_AND_SUB_8:
6321     case BUILT_IN_FETCH_AND_SUB_16:
6322       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6323       target = expand_builtin_sync_operation (mode, exp, MINUS,
6324                                               false, target, ignore);
6325       if (target)
6326         return target;
6327       break;
6328
6329     case BUILT_IN_FETCH_AND_OR_1:
6330     case BUILT_IN_FETCH_AND_OR_2:
6331     case BUILT_IN_FETCH_AND_OR_4:
6332     case BUILT_IN_FETCH_AND_OR_8:
6333     case BUILT_IN_FETCH_AND_OR_16:
6334       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6335       target = expand_builtin_sync_operation (mode, exp, IOR,
6336                                               false, target, ignore);
6337       if (target)
6338         return target;
6339       break;
6340
6341     case BUILT_IN_FETCH_AND_AND_1:
6342     case BUILT_IN_FETCH_AND_AND_2:
6343     case BUILT_IN_FETCH_AND_AND_4:
6344     case BUILT_IN_FETCH_AND_AND_8:
6345     case BUILT_IN_FETCH_AND_AND_16:
6346       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6347       target = expand_builtin_sync_operation (mode, exp, AND,
6348                                               false, target, ignore);
6349       if (target)
6350         return target;
6351       break;
6352
6353     case BUILT_IN_FETCH_AND_XOR_1:
6354     case BUILT_IN_FETCH_AND_XOR_2:
6355     case BUILT_IN_FETCH_AND_XOR_4:
6356     case BUILT_IN_FETCH_AND_XOR_8:
6357     case BUILT_IN_FETCH_AND_XOR_16:
6358       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6359       target = expand_builtin_sync_operation (mode, exp, XOR,
6360                                               false, target, ignore);
6361       if (target)
6362         return target;
6363       break;
6364
6365     case BUILT_IN_FETCH_AND_NAND_1:
6366     case BUILT_IN_FETCH_AND_NAND_2:
6367     case BUILT_IN_FETCH_AND_NAND_4:
6368     case BUILT_IN_FETCH_AND_NAND_8:
6369     case BUILT_IN_FETCH_AND_NAND_16:
6370       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6371       target = expand_builtin_sync_operation (mode, exp, NOT,
6372                                               false, target, ignore);
6373       if (target)
6374         return target;
6375       break;
6376
6377     case BUILT_IN_ADD_AND_FETCH_1:
6378     case BUILT_IN_ADD_AND_FETCH_2:
6379     case BUILT_IN_ADD_AND_FETCH_4:
6380     case BUILT_IN_ADD_AND_FETCH_8:
6381     case BUILT_IN_ADD_AND_FETCH_16:
6382       mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6383       target = expand_builtin_sync_operation (mode, exp, PLUS,
6384                                               true, target, ignore);
6385       if (target)
6386         return target;
6387       break;
6388
6389     case BUILT_IN_SUB_AND_FETCH_1:
6390     case BUILT_IN_SUB_AND_FETCH_2:
6391     case BUILT_IN_SUB_AND_FETCH_4:
6392     case BUILT_IN_SUB_AND_FETCH_8:
6393     case BUILT_IN_SUB_AND_FETCH_16:
6394       mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6395       target = expand_builtin_sync_operation (mode, exp, MINUS,
6396                                               true, target, ignore);
6397       if (target)
6398         return target;
6399       break;
6400
6401     case BUILT_IN_OR_AND_FETCH_1:
6402     case BUILT_IN_OR_AND_FETCH_2:
6403     case BUILT_IN_OR_AND_FETCH_4:
6404     case BUILT_IN_OR_AND_FETCH_8:
6405     case BUILT_IN_OR_AND_FETCH_16:
6406       mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6407       target = expand_builtin_sync_operation (mode, exp, IOR,
6408                                               true, target, ignore);
6409       if (target)
6410         return target;
6411       break;
6412
6413     case BUILT_IN_AND_AND_FETCH_1:
6414     case BUILT_IN_AND_AND_FETCH_2:
6415     case BUILT_IN_AND_AND_FETCH_4:
6416     case BUILT_IN_AND_AND_FETCH_8:
6417     case BUILT_IN_AND_AND_FETCH_16:
6418       mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6419       target = expand_builtin_sync_operation (mode, exp, AND,
6420                                               true, target, ignore);
6421       if (target)
6422         return target;
6423       break;
6424
6425     case BUILT_IN_XOR_AND_FETCH_1:
6426     case BUILT_IN_XOR_AND_FETCH_2:
6427     case BUILT_IN_XOR_AND_FETCH_4:
6428     case BUILT_IN_XOR_AND_FETCH_8:
6429     case BUILT_IN_XOR_AND_FETCH_16:
6430       mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6431       target = expand_builtin_sync_operation (mode, exp, XOR,
6432                                               true, target, ignore);
6433       if (target)
6434         return target;
6435       break;
6436
6437     case BUILT_IN_NAND_AND_FETCH_1:
6438     case BUILT_IN_NAND_AND_FETCH_2:
6439     case BUILT_IN_NAND_AND_FETCH_4:
6440     case BUILT_IN_NAND_AND_FETCH_8:
6441     case BUILT_IN_NAND_AND_FETCH_16:
6442       mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6443       target = expand_builtin_sync_operation (mode, exp, NOT,
6444                                               true, target, ignore);
6445       if (target)
6446         return target;
6447       break;
6448
6449     case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6450     case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6451     case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6452     case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6453     case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6454       if (mode == VOIDmode)
6455         mode = TYPE_MODE (boolean_type_node);
6456       if (!target || !register_operand (target, mode))
6457         target = gen_reg_rtx (mode);
6458
6459       mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6460       target = expand_builtin_compare_and_swap (mode, exp, true, target);
6461       if (target)
6462         return target;
6463       break;
6464
6465     case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6466     case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6467     case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6468     case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6469     case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6470       mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6471       target = expand_builtin_compare_and_swap (mode, exp, false, target);
6472       if (target)
6473         return target;
6474       break;
6475
6476     case BUILT_IN_LOCK_TEST_AND_SET_1:
6477     case BUILT_IN_LOCK_TEST_AND_SET_2:
6478     case BUILT_IN_LOCK_TEST_AND_SET_4:
6479     case BUILT_IN_LOCK_TEST_AND_SET_8:
6480     case BUILT_IN_LOCK_TEST_AND_SET_16:
6481       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6482       target = expand_builtin_lock_test_and_set (mode, exp, target);
6483       if (target)
6484         return target;
6485       break;
6486
6487     case BUILT_IN_LOCK_RELEASE_1:
6488     case BUILT_IN_LOCK_RELEASE_2:
6489     case BUILT_IN_LOCK_RELEASE_4:
6490     case BUILT_IN_LOCK_RELEASE_8:
6491     case BUILT_IN_LOCK_RELEASE_16:
6492       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6493       expand_builtin_lock_release (mode, exp);
6494       return const0_rtx;
6495
6496     case BUILT_IN_SYNCHRONIZE:
6497       expand_builtin_synchronize ();
6498       return const0_rtx;
6499
6500     case BUILT_IN_OBJECT_SIZE:
6501       return expand_builtin_object_size (exp);
6502
6503     case BUILT_IN_MEMCPY_CHK:
6504     case BUILT_IN_MEMPCPY_CHK:
6505     case BUILT_IN_MEMMOVE_CHK:
6506     case BUILT_IN_MEMSET_CHK:
6507       target = expand_builtin_memory_chk (exp, target, mode, fcode);
6508       if (target)
6509         return target;
6510       break;
6511
6512     case BUILT_IN_STRCPY_CHK:
6513     case BUILT_IN_STPCPY_CHK:
6514     case BUILT_IN_STRNCPY_CHK:
6515     case BUILT_IN_STRCAT_CHK:
6516     case BUILT_IN_STRNCAT_CHK:
6517     case BUILT_IN_SNPRINTF_CHK:
6518     case BUILT_IN_VSNPRINTF_CHK:
6519       maybe_emit_chk_warning (exp, fcode);
6520       break;
6521
6522     case BUILT_IN_SPRINTF_CHK:
6523     case BUILT_IN_VSPRINTF_CHK:
6524       maybe_emit_sprintf_chk_warning (exp, fcode);
6525       break;
6526
6527     case BUILT_IN_FREE:
6528       maybe_emit_free_warning (exp);
6529       break;
6530
6531     default:    /* just do library call, if unknown builtin */
6532       break;
6533     }
6534
6535   /* The switch statement above can drop through to cause the function
6536      to be called normally.  */
6537   return expand_call (exp, target, ignore);
6538 }
6539
6540 /* Determine whether a tree node represents a call to a built-in
6541    function.  If the tree T is a call to a built-in function with
6542    the right number of arguments of the appropriate types, return
6543    the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6544    Otherwise the return value is END_BUILTINS.  */
6545
6546 enum built_in_function
6547 builtin_mathfn_code (const_tree t)
6548 {
6549   const_tree fndecl, arg, parmlist;
6550   const_tree argtype, parmtype;
6551   const_call_expr_arg_iterator iter;
6552
6553   if (TREE_CODE (t) != CALL_EXPR
6554       || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6555     return END_BUILTINS;
6556
6557   fndecl = get_callee_fndecl (t);
6558   if (fndecl == NULL_TREE
6559       || TREE_CODE (fndecl) != FUNCTION_DECL
6560       || ! DECL_BUILT_IN (fndecl)
6561       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6562     return END_BUILTINS;
6563
6564   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6565   init_const_call_expr_arg_iterator (t, &iter);
6566   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6567     {
6568       /* If a function doesn't take a variable number of arguments,
6569          the last element in the list will have type `void'.  */
6570       parmtype = TREE_VALUE (parmlist);
6571       if (VOID_TYPE_P (parmtype))
6572         {
6573           if (more_const_call_expr_args_p (&iter))
6574             return END_BUILTINS;
6575           return DECL_FUNCTION_CODE (fndecl);
6576         }
6577
6578       if (! more_const_call_expr_args_p (&iter))
6579         return END_BUILTINS;
6580
6581       arg = next_const_call_expr_arg (&iter);
6582       argtype = TREE_TYPE (arg);
6583
6584       if (SCALAR_FLOAT_TYPE_P (parmtype))
6585         {
6586           if (! SCALAR_FLOAT_TYPE_P (argtype))
6587             return END_BUILTINS;
6588         }
6589       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6590         {
6591           if (! COMPLEX_FLOAT_TYPE_P (argtype))
6592             return END_BUILTINS;
6593         }
6594       else if (POINTER_TYPE_P (parmtype))
6595         {
6596           if (! POINTER_TYPE_P (argtype))
6597             return END_BUILTINS;
6598         }
6599       else if (INTEGRAL_TYPE_P (parmtype))
6600         {
6601           if (! INTEGRAL_TYPE_P (argtype))
6602             return END_BUILTINS;
6603         }
6604       else
6605         return END_BUILTINS;
6606     }
6607
6608   /* Variable-length argument list.  */
6609   return DECL_FUNCTION_CODE (fndecl);
6610 }
6611
6612 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6613    evaluate to a constant.  */
6614
6615 static tree
6616 fold_builtin_constant_p (tree arg)
6617 {
6618   /* We return 1 for a numeric type that's known to be a constant
6619      value at compile-time or for an aggregate type that's a
6620      literal constant.  */
6621   STRIP_NOPS (arg);
6622
6623   /* If we know this is a constant, emit the constant of one.  */
6624   if (CONSTANT_CLASS_P (arg)
6625       || (TREE_CODE (arg) == CONSTRUCTOR
6626           && TREE_CONSTANT (arg)))
6627     return integer_one_node;
6628   if (TREE_CODE (arg) == ADDR_EXPR)
6629     {
6630        tree op = TREE_OPERAND (arg, 0);
6631        if (TREE_CODE (op) == STRING_CST
6632            || (TREE_CODE (op) == ARRAY_REF
6633                && integer_zerop (TREE_OPERAND (op, 1))
6634                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6635          return integer_one_node;
6636     }
6637
6638   /* If this expression has side effects, show we don't know it to be a
6639      constant.  Likewise if it's a pointer or aggregate type since in
6640      those case we only want literals, since those are only optimized
6641      when generating RTL, not later.
6642      And finally, if we are compiling an initializer, not code, we
6643      need to return a definite result now; there's not going to be any
6644      more optimization done.  */
6645   if (TREE_SIDE_EFFECTS (arg)
6646       || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6647       || POINTER_TYPE_P (TREE_TYPE (arg))
6648       || cfun == 0
6649       || folding_initializer)
6650     return integer_zero_node;
6651
6652   return NULL_TREE;
6653 }
6654
6655 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6656    return it as a truthvalue.  */
6657
6658 static tree
6659 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6660 {
6661   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6662
6663   fn = built_in_decls[BUILT_IN_EXPECT];
6664   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6665   ret_type = TREE_TYPE (TREE_TYPE (fn));
6666   pred_type = TREE_VALUE (arg_types);
6667   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6668
6669   pred = fold_convert_loc (loc, pred_type, pred);
6670   expected = fold_convert_loc (loc, expected_type, expected);
6671   call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6672
6673   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6674                  build_int_cst (ret_type, 0));
6675 }
6676
6677 /* Fold a call to builtin_expect with arguments ARG0 and ARG1.  Return
6678    NULL_TREE if no simplification is possible.  */
6679
6680 static tree
6681 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
6682 {
6683   tree inner, fndecl;
6684   enum tree_code code;
6685
6686   /* If this is a builtin_expect within a builtin_expect keep the
6687      inner one.  See through a comparison against a constant.  It
6688      might have been added to create a thruthvalue.  */
6689   inner = arg0;
6690   if (COMPARISON_CLASS_P (inner)
6691       && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6692     inner = TREE_OPERAND (inner, 0);
6693
6694   if (TREE_CODE (inner) == CALL_EXPR
6695       && (fndecl = get_callee_fndecl (inner))
6696       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6697       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6698     return arg0;
6699
6700   /* Distribute the expected value over short-circuiting operators.
6701      See through the cast from truthvalue_type_node to long.  */
6702   inner = arg0;
6703   while (TREE_CODE (inner) == NOP_EXPR
6704          && INTEGRAL_TYPE_P (TREE_TYPE (inner))
6705          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
6706     inner = TREE_OPERAND (inner, 0);
6707
6708   code = TREE_CODE (inner);
6709   if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6710     {
6711       tree op0 = TREE_OPERAND (inner, 0);
6712       tree op1 = TREE_OPERAND (inner, 1);
6713
6714       op0 = build_builtin_expect_predicate (loc, op0, arg1);
6715       op1 = build_builtin_expect_predicate (loc, op1, arg1);
6716       inner = build2 (code, TREE_TYPE (inner), op0, op1);
6717
6718       return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6719     }
6720
6721   /* If the argument isn't invariant then there's nothing else we can do.  */
6722   if (!TREE_CONSTANT (arg0))
6723     return NULL_TREE;
6724
6725   /* If we expect that a comparison against the argument will fold to
6726      a constant return the constant.  In practice, this means a true
6727      constant or the address of a non-weak symbol.  */
6728   inner = arg0;
6729   STRIP_NOPS (inner);
6730   if (TREE_CODE (inner) == ADDR_EXPR)
6731     {
6732       do
6733         {
6734           inner = TREE_OPERAND (inner, 0);
6735         }
6736       while (TREE_CODE (inner) == COMPONENT_REF
6737              || TREE_CODE (inner) == ARRAY_REF);
6738       if ((TREE_CODE (inner) == VAR_DECL
6739            || TREE_CODE (inner) == FUNCTION_DECL)
6740           && DECL_WEAK (inner))
6741         return NULL_TREE;
6742     }
6743
6744   /* Otherwise, ARG0 already has the proper type for the return value.  */
6745   return arg0;
6746 }
6747
6748 /* Fold a call to __builtin_classify_type with argument ARG.  */
6749
6750 static tree
6751 fold_builtin_classify_type (tree arg)
6752 {
6753   if (arg == 0)
6754     return build_int_cst (NULL_TREE, no_type_class);
6755
6756   return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
6757 }
6758
6759 /* Fold a call to __builtin_strlen with argument ARG.  */
6760
6761 static tree
6762 fold_builtin_strlen (location_t loc, tree type, tree arg)
6763 {
6764   if (!validate_arg (arg, POINTER_TYPE))
6765     return NULL_TREE;
6766   else
6767     {
6768       tree len = c_strlen (arg, 0);
6769
6770       if (len)
6771         return fold_convert_loc (loc, type, len);
6772
6773       return NULL_TREE;
6774     }
6775 }
6776
6777 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
6778
6779 static tree
6780 fold_builtin_inf (location_t loc, tree type, int warn)
6781 {
6782   REAL_VALUE_TYPE real;
6783
6784   /* __builtin_inff is intended to be usable to define INFINITY on all
6785      targets.  If an infinity is not available, INFINITY expands "to a
6786      positive constant of type float that overflows at translation
6787      time", footnote "In this case, using INFINITY will violate the
6788      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6789      Thus we pedwarn to ensure this constraint violation is
6790      diagnosed.  */
6791   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6792     pedwarn (loc, 0, "target format does not support infinity");
6793
6794   real_inf (&real);
6795   return build_real (type, real);
6796 }
6797
6798 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG.  */
6799
6800 static tree
6801 fold_builtin_nan (tree arg, tree type, int quiet)
6802 {
6803   REAL_VALUE_TYPE real;
6804   const char *str;
6805
6806   if (!validate_arg (arg, POINTER_TYPE))
6807     return NULL_TREE;
6808   str = c_getstr (arg);
6809   if (!str)
6810     return NULL_TREE;
6811
6812   if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
6813     return NULL_TREE;
6814
6815   return build_real (type, real);
6816 }
6817
6818 /* Return true if the floating point expression T has an integer value.
6819    We also allow +Inf, -Inf and NaN to be considered integer values.  */
6820
6821 static bool
6822 integer_valued_real_p (tree t)
6823 {
6824   switch (TREE_CODE (t))
6825     {
6826     case FLOAT_EXPR:
6827       return true;
6828
6829     case ABS_EXPR:
6830     case SAVE_EXPR:
6831       return integer_valued_real_p (TREE_OPERAND (t, 0));
6832
6833     case COMPOUND_EXPR:
6834     case MODIFY_EXPR:
6835     case BIND_EXPR:
6836       return integer_valued_real_p (TREE_OPERAND (t, 1));
6837
6838     case PLUS_EXPR:
6839     case MINUS_EXPR:
6840     case MULT_EXPR:
6841     case MIN_EXPR:
6842     case MAX_EXPR:
6843       return integer_valued_real_p (TREE_OPERAND (t, 0))
6844              && integer_valued_real_p (TREE_OPERAND (t, 1));
6845
6846     case COND_EXPR:
6847       return integer_valued_real_p (TREE_OPERAND (t, 1))
6848              && integer_valued_real_p (TREE_OPERAND (t, 2));
6849
6850     case REAL_CST:
6851       return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
6852
6853     case NOP_EXPR:
6854       {
6855         tree type = TREE_TYPE (TREE_OPERAND (t, 0));
6856         if (TREE_CODE (type) == INTEGER_TYPE)
6857           return true;
6858         if (TREE_CODE (type) == REAL_TYPE)
6859           return integer_valued_real_p (TREE_OPERAND (t, 0));
6860         break;
6861       }
6862
6863     case CALL_EXPR:
6864       switch (builtin_mathfn_code (t))
6865         {
6866         CASE_FLT_FN (BUILT_IN_CEIL):
6867         CASE_FLT_FN (BUILT_IN_FLOOR):
6868         CASE_FLT_FN (BUILT_IN_NEARBYINT):
6869         CASE_FLT_FN (BUILT_IN_RINT):
6870         CASE_FLT_FN (BUILT_IN_ROUND):
6871         CASE_FLT_FN (BUILT_IN_TRUNC):
6872           return true;
6873
6874         CASE_FLT_FN (BUILT_IN_FMIN):
6875         CASE_FLT_FN (BUILT_IN_FMAX):
6876           return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
6877             && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
6878
6879         default:
6880           break;
6881         }
6882       break;
6883
6884     default:
6885       break;
6886     }
6887   return false;
6888 }
6889
6890 /* FNDECL is assumed to be a builtin where truncation can be propagated
6891    across (for instance floor((double)f) == (double)floorf (f).
6892    Do the transformation for a call with argument ARG.  */
6893
6894 static tree
6895 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
6896 {
6897   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6898
6899   if (!validate_arg (arg, REAL_TYPE))
6900     return NULL_TREE;
6901
6902   /* Integer rounding functions are idempotent.  */
6903   if (fcode == builtin_mathfn_code (arg))
6904     return arg;
6905
6906   /* If argument is already integer valued, and we don't need to worry
6907      about setting errno, there's no need to perform rounding.  */
6908   if (! flag_errno_math && integer_valued_real_p (arg))
6909     return arg;
6910
6911   if (optimize)
6912     {
6913       tree arg0 = strip_float_extensions (arg);
6914       tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
6915       tree newtype = TREE_TYPE (arg0);
6916       tree decl;
6917
6918       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6919           && (decl = mathfn_built_in (newtype, fcode)))
6920         return fold_convert_loc (loc, ftype,
6921                                  build_call_expr_loc (loc, decl, 1,
6922                                                   fold_convert_loc (loc,
6923                                                                     newtype,
6924                                                                     arg0)));
6925     }
6926   return NULL_TREE;
6927 }
6928
6929 /* FNDECL is assumed to be builtin which can narrow the FP type of
6930    the argument, for instance lround((double)f) -> lroundf (f).
6931    Do the transformation for a call with argument ARG.  */
6932
6933 static tree
6934 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
6935 {
6936   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6937
6938   if (!validate_arg (arg, REAL_TYPE))
6939     return NULL_TREE;
6940
6941   /* If argument is already integer valued, and we don't need to worry
6942      about setting errno, there's no need to perform rounding.  */
6943   if (! flag_errno_math && integer_valued_real_p (arg))
6944     return fold_build1_loc (loc, FIX_TRUNC_EXPR,
6945                         TREE_TYPE (TREE_TYPE (fndecl)), arg);
6946
6947   if (optimize)
6948     {
6949       tree ftype = TREE_TYPE (arg);
6950       tree arg0 = strip_float_extensions (arg);
6951       tree newtype = TREE_TYPE (arg0);
6952       tree decl;
6953
6954       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6955           && (decl = mathfn_built_in (newtype, fcode)))
6956         return build_call_expr_loc (loc, decl, 1,
6957                                 fold_convert_loc (loc, newtype, arg0));
6958     }
6959
6960   /* Canonicalize llround (x) to lround (x) on LP64 targets where
6961      sizeof (long long) == sizeof (long).  */
6962   if (TYPE_PRECISION (long_long_integer_type_node)
6963       == TYPE_PRECISION (long_integer_type_node))
6964     {
6965       tree newfn = NULL_TREE;
6966       switch (fcode)
6967         {
6968         CASE_FLT_FN (BUILT_IN_LLCEIL):
6969           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
6970           break;
6971
6972         CASE_FLT_FN (BUILT_IN_LLFLOOR):
6973           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
6974           break;
6975
6976         CASE_FLT_FN (BUILT_IN_LLROUND):
6977           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
6978           break;
6979
6980         CASE_FLT_FN (BUILT_IN_LLRINT):
6981           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
6982           break;
6983
6984         default:
6985           break;
6986         }
6987
6988       if (newfn)
6989         {
6990           tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
6991           return fold_convert_loc (loc,
6992                                    TREE_TYPE (TREE_TYPE (fndecl)), newcall);
6993         }
6994     }
6995
6996   return NULL_TREE;
6997 }
6998
6999 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG.  TYPE is the
7000    return type.  Return NULL_TREE if no simplification can be made.  */
7001
7002 static tree
7003 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7004 {
7005   tree res;
7006
7007   if (!validate_arg (arg, COMPLEX_TYPE)
7008       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7009     return NULL_TREE;
7010
7011   /* Calculate the result when the argument is a constant.  */
7012   if (TREE_CODE (arg) == COMPLEX_CST
7013       && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7014                               type, mpfr_hypot)))
7015     return res;
7016
7017   if (TREE_CODE (arg) == COMPLEX_EXPR)
7018     {
7019       tree real = TREE_OPERAND (arg, 0);
7020       tree imag = TREE_OPERAND (arg, 1);
7021
7022       /* If either part is zero, cabs is fabs of the other.  */
7023       if (real_zerop (real))
7024         return fold_build1_loc (loc, ABS_EXPR, type, imag);
7025       if (real_zerop (imag))
7026         return fold_build1_loc (loc, ABS_EXPR, type, real);
7027
7028       /* cabs(x+xi) -> fabs(x)*sqrt(2).  */
7029       if (flag_unsafe_math_optimizations
7030           && operand_equal_p (real, imag, OEP_PURE_SAME))
7031         {
7032           const REAL_VALUE_TYPE sqrt2_trunc
7033             = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7034           STRIP_NOPS (real);
7035           return fold_build2_loc (loc, MULT_EXPR, type,
7036                               fold_build1_loc (loc, ABS_EXPR, type, real),
7037                               build_real (type, sqrt2_trunc));
7038         }
7039     }
7040
7041   /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z).  */
7042   if (TREE_CODE (arg) == NEGATE_EXPR
7043       || TREE_CODE (arg) == CONJ_EXPR)
7044     return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7045
7046   /* Don't do this when optimizing for size.  */
7047   if (flag_unsafe_math_optimizations
7048       && optimize && optimize_function_for_speed_p (cfun))
7049     {
7050       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7051
7052       if (sqrtfn != NULL_TREE)
7053         {
7054           tree rpart, ipart, result;
7055
7056           arg = builtin_save_expr (arg);
7057
7058           rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7059           ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7060
7061           rpart = builtin_save_expr (rpart);
7062           ipart = builtin_save_expr (ipart);
7063
7064           result = fold_build2_loc (loc, PLUS_EXPR, type,
7065                                 fold_build2_loc (loc, MULT_EXPR, type,
7066                                              rpart, rpart),
7067                                 fold_build2_loc (loc, MULT_EXPR, type,
7068                                              ipart, ipart));
7069
7070           return build_call_expr_loc (loc, sqrtfn, 1, result);
7071         }
7072     }
7073
7074   return NULL_TREE;
7075 }
7076
7077 /* Build a complex (inf +- 0i) for the result of cproj.  TYPE is the
7078    complex tree type of the result.  If NEG is true, the imaginary
7079    zero is negative.  */
7080
7081 static tree
7082 build_complex_cproj (tree type, bool neg)
7083 {
7084   REAL_VALUE_TYPE rinf, rzero = dconst0;
7085
7086   real_inf (&rinf);
7087   rzero.sign = neg;
7088   return build_complex (type, build_real (TREE_TYPE (type), rinf),
7089                         build_real (TREE_TYPE (type), rzero));
7090 }
7091
7092 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG.  TYPE is the
7093    return type.  Return NULL_TREE if no simplification can be made.  */
7094
7095 static tree
7096 fold_builtin_cproj (location_t loc, tree arg, tree type)
7097 {
7098   if (!validate_arg (arg, COMPLEX_TYPE)
7099       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7100     return NULL_TREE;
7101
7102   /* If there are no infinities, return arg.  */
7103   if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type))))
7104     return non_lvalue_loc (loc, arg);
7105
7106   /* Calculate the result when the argument is a constant.  */
7107   if (TREE_CODE (arg) == COMPLEX_CST)
7108     {
7109       const REAL_VALUE_TYPE *real = TREE_REAL_CST_PTR (TREE_REALPART (arg));
7110       const REAL_VALUE_TYPE *imag = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
7111
7112       if (real_isinf (real) || real_isinf (imag))
7113         return build_complex_cproj (type, imag->sign);
7114       else
7115         return arg;
7116     }
7117   else if (TREE_CODE (arg) == COMPLEX_EXPR)
7118     {
7119       tree real = TREE_OPERAND (arg, 0);
7120       tree imag = TREE_OPERAND (arg, 1);
7121
7122       STRIP_NOPS (real);
7123       STRIP_NOPS (imag);
7124
7125       /* If the real part is inf and the imag part is known to be
7126          nonnegative, return (inf + 0i).  Remember side-effects are
7127          possible in the imag part.  */
7128       if (TREE_CODE (real) == REAL_CST
7129           && real_isinf (TREE_REAL_CST_PTR (real))
7130           && tree_expr_nonnegative_p (imag))
7131         return omit_one_operand_loc (loc, type,
7132                                      build_complex_cproj (type, false),
7133                                      arg);
7134
7135       /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7136          Remember side-effects are possible in the real part.  */
7137       if (TREE_CODE (imag) == REAL_CST
7138           && real_isinf (TREE_REAL_CST_PTR (imag)))
7139         return
7140           omit_one_operand_loc (loc, type,
7141                                 build_complex_cproj (type, TREE_REAL_CST_PTR
7142                                                      (imag)->sign), arg);
7143     }
7144
7145   return NULL_TREE;
7146 }
7147
7148 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7149    Return NULL_TREE if no simplification can be made.  */
7150
7151 static tree
7152 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7153 {
7154
7155   enum built_in_function fcode;
7156   tree res;
7157
7158   if (!validate_arg (arg, REAL_TYPE))
7159     return NULL_TREE;
7160
7161   /* Calculate the result when the argument is a constant.  */
7162   if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7163     return res;
7164
7165   /* Optimize sqrt(expN(x)) = expN(x*0.5).  */
7166   fcode = builtin_mathfn_code (arg);
7167   if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7168     {
7169       tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7170       arg = fold_build2_loc (loc, MULT_EXPR, type,
7171                          CALL_EXPR_ARG (arg, 0),
7172                          build_real (type, dconsthalf));
7173       return build_call_expr_loc (loc, expfn, 1, arg);
7174     }
7175
7176   /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)).  */
7177   if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7178     {
7179       tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7180
7181       if (powfn)
7182         {
7183           tree arg0 = CALL_EXPR_ARG (arg, 0);
7184           tree tree_root;
7185           /* The inner root was either sqrt or cbrt.  */
7186           /* This was a conditional expression but it triggered a bug
7187              in Sun C 5.5.  */
7188           REAL_VALUE_TYPE dconstroot;
7189           if (BUILTIN_SQRT_P (fcode))
7190             dconstroot = dconsthalf;
7191           else
7192             dconstroot = dconst_third ();
7193
7194           /* Adjust for the outer root.  */
7195           SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7196           dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7197           tree_root = build_real (type, dconstroot);
7198           return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7199         }
7200     }
7201
7202   /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5).  */
7203   if (flag_unsafe_math_optimizations
7204       && (fcode == BUILT_IN_POW
7205           || fcode == BUILT_IN_POWF
7206           || fcode == BUILT_IN_POWL))
7207     {
7208       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7209       tree arg0 = CALL_EXPR_ARG (arg, 0);
7210       tree arg1 = CALL_EXPR_ARG (arg, 1);
7211       tree narg1;
7212       if (!tree_expr_nonnegative_p (arg0))
7213         arg0 = build1 (ABS_EXPR, type, arg0);
7214       narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7215                            build_real (type, dconsthalf));
7216       return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7217     }
7218
7219   return NULL_TREE;
7220 }
7221
7222 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7223    Return NULL_TREE if no simplification can be made.  */
7224
7225 static tree
7226 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7227 {
7228   const enum built_in_function fcode = builtin_mathfn_code (arg);
7229   tree res;
7230
7231   if (!validate_arg (arg, REAL_TYPE))
7232     return NULL_TREE;
7233
7234   /* Calculate the result when the argument is a constant.  */
7235   if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7236     return res;
7237
7238   if (flag_unsafe_math_optimizations)
7239     {
7240       /* Optimize cbrt(expN(x)) -> expN(x/3).  */
7241       if (BUILTIN_EXPONENT_P (fcode))
7242         {
7243           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7244           const REAL_VALUE_TYPE third_trunc =
7245             real_value_truncate (TYPE_MODE (type), dconst_third ());
7246           arg = fold_build2_loc (loc, MULT_EXPR, type,
7247                              CALL_EXPR_ARG (arg, 0),
7248                              build_real (type, third_trunc));
7249           return build_call_expr_loc (loc, expfn, 1, arg);
7250         }
7251
7252       /* Optimize cbrt(sqrt(x)) -> pow(x,1/6).  */
7253       if (BUILTIN_SQRT_P (fcode))
7254         {
7255           tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7256
7257           if (powfn)
7258             {
7259               tree arg0 = CALL_EXPR_ARG (arg, 0);
7260               tree tree_root;
7261               REAL_VALUE_TYPE dconstroot = dconst_third ();
7262
7263               SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7264               dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7265               tree_root = build_real (type, dconstroot);
7266               return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7267             }
7268         }
7269
7270       /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative.  */
7271       if (BUILTIN_CBRT_P (fcode))
7272         {
7273           tree arg0 = CALL_EXPR_ARG (arg, 0);
7274           if (tree_expr_nonnegative_p (arg0))
7275             {
7276               tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7277
7278               if (powfn)
7279                 {
7280                   tree tree_root;
7281                   REAL_VALUE_TYPE dconstroot;
7282
7283                   real_arithmetic (&dconstroot, MULT_EXPR,
7284                                    dconst_third_ptr (), dconst_third_ptr ());
7285                   dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7286                   tree_root = build_real (type, dconstroot);
7287                   return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7288                 }
7289             }
7290         }
7291
7292       /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative.  */
7293       if (fcode == BUILT_IN_POW
7294           || fcode == BUILT_IN_POWF
7295           || fcode == BUILT_IN_POWL)
7296         {
7297           tree arg00 = CALL_EXPR_ARG (arg, 0);
7298           tree arg01 = CALL_EXPR_ARG (arg, 1);
7299           if (tree_expr_nonnegative_p (arg00))
7300             {
7301               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7302               const REAL_VALUE_TYPE dconstroot
7303                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7304               tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7305                                          build_real (type, dconstroot));
7306               return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7307             }
7308         }
7309     }
7310   return NULL_TREE;
7311 }
7312
7313 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7314    TYPE is the type of the return value.  Return NULL_TREE if no
7315    simplification can be made.  */
7316
7317 static tree
7318 fold_builtin_cos (location_t loc,
7319                   tree arg, tree type, tree fndecl)
7320 {
7321   tree res, narg;
7322
7323   if (!validate_arg (arg, REAL_TYPE))
7324     return NULL_TREE;
7325
7326   /* Calculate the result when the argument is a constant.  */
7327   if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7328     return res;
7329
7330   /* Optimize cos(-x) into cos (x).  */
7331   if ((narg = fold_strip_sign_ops (arg)))
7332     return build_call_expr_loc (loc, fndecl, 1, narg);
7333
7334   return NULL_TREE;
7335 }
7336
7337 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7338    Return NULL_TREE if no simplification can be made.  */
7339
7340 static tree
7341 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7342 {
7343   if (validate_arg (arg, REAL_TYPE))
7344     {
7345       tree res, narg;
7346
7347       /* Calculate the result when the argument is a constant.  */
7348       if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7349         return res;
7350
7351       /* Optimize cosh(-x) into cosh (x).  */
7352       if ((narg = fold_strip_sign_ops (arg)))
7353         return build_call_expr_loc (loc, fndecl, 1, narg);
7354     }
7355
7356   return NULL_TREE;
7357 }
7358
7359 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7360    argument ARG.  TYPE is the type of the return value.  Return
7361    NULL_TREE if no simplification can be made.  */
7362
7363 static tree
7364 fold_builtin_ccos (location_t loc, tree arg, tree type, tree fndecl,
7365                    bool hyper)
7366 {
7367   if (validate_arg (arg, COMPLEX_TYPE)
7368       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7369     {
7370       tree tmp;
7371
7372       /* Calculate the result when the argument is a constant.  */
7373       if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7374         return tmp;
7375
7376       /* Optimize fn(-x) into fn(x).  */
7377       if ((tmp = fold_strip_sign_ops (arg)))
7378         return build_call_expr_loc (loc, fndecl, 1, tmp);
7379     }
7380
7381   return NULL_TREE;
7382 }
7383
7384 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7385    Return NULL_TREE if no simplification can be made.  */
7386
7387 static tree
7388 fold_builtin_tan (tree arg, tree type)
7389 {
7390   enum built_in_function fcode;
7391   tree res;
7392
7393   if (!validate_arg (arg, REAL_TYPE))
7394     return NULL_TREE;
7395
7396   /* Calculate the result when the argument is a constant.  */
7397   if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7398     return res;
7399
7400   /* Optimize tan(atan(x)) = x.  */
7401   fcode = builtin_mathfn_code (arg);
7402   if (flag_unsafe_math_optimizations
7403       && (fcode == BUILT_IN_ATAN
7404           || fcode == BUILT_IN_ATANF
7405           || fcode == BUILT_IN_ATANL))
7406     return CALL_EXPR_ARG (arg, 0);
7407
7408   return NULL_TREE;
7409 }
7410
7411 /* Fold function call to builtin sincos, sincosf, or sincosl.  Return
7412    NULL_TREE if no simplification can be made.  */
7413
7414 static tree
7415 fold_builtin_sincos (location_t loc,
7416                      tree arg0, tree arg1, tree arg2)
7417 {
7418   tree type;
7419   tree res, fn, call;
7420
7421   if (!validate_arg (arg0, REAL_TYPE)
7422       || !validate_arg (arg1, POINTER_TYPE)
7423       || !validate_arg (arg2, POINTER_TYPE))
7424     return NULL_TREE;
7425
7426   type = TREE_TYPE (arg0);
7427
7428   /* Calculate the result when the argument is a constant.  */
7429   if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7430     return res;
7431
7432   /* Canonicalize sincos to cexpi.  */
7433   if (!TARGET_C99_FUNCTIONS)
7434     return NULL_TREE;
7435   fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7436   if (!fn)
7437     return NULL_TREE;
7438
7439   call = build_call_expr_loc (loc, fn, 1, arg0);
7440   call = builtin_save_expr (call);
7441
7442   return build2 (COMPOUND_EXPR, void_type_node,
7443                  build2 (MODIFY_EXPR, void_type_node,
7444                          build_fold_indirect_ref_loc (loc, arg1),
7445                          build1 (IMAGPART_EXPR, type, call)),
7446                  build2 (MODIFY_EXPR, void_type_node,
7447                          build_fold_indirect_ref_loc (loc, arg2),
7448                          build1 (REALPART_EXPR, type, call)));
7449 }
7450
7451 /* Fold function call to builtin cexp, cexpf, or cexpl.  Return
7452    NULL_TREE if no simplification can be made.  */
7453
7454 static tree
7455 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7456 {
7457   tree rtype;
7458   tree realp, imagp, ifn;
7459   tree res;
7460
7461   if (!validate_arg (arg0, COMPLEX_TYPE)
7462       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7463     return NULL_TREE;
7464
7465   /* Calculate the result when the argument is a constant.  */
7466   if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7467     return res;
7468
7469   rtype = TREE_TYPE (TREE_TYPE (arg0));
7470
7471   /* In case we can figure out the real part of arg0 and it is constant zero
7472      fold to cexpi.  */
7473   if (!TARGET_C99_FUNCTIONS)
7474     return NULL_TREE;
7475   ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7476   if (!ifn)
7477     return NULL_TREE;
7478
7479   if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7480       && real_zerop (realp))
7481     {
7482       tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7483       return build_call_expr_loc (loc, ifn, 1, narg);
7484     }
7485
7486   /* In case we can easily decompose real and imaginary parts split cexp
7487      to exp (r) * cexpi (i).  */
7488   if (flag_unsafe_math_optimizations
7489       && realp)
7490     {
7491       tree rfn, rcall, icall;
7492
7493       rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7494       if (!rfn)
7495         return NULL_TREE;
7496
7497       imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7498       if (!imagp)
7499         return NULL_TREE;
7500
7501       icall = build_call_expr_loc (loc, ifn, 1, imagp);
7502       icall = builtin_save_expr (icall);
7503       rcall = build_call_expr_loc (loc, rfn, 1, realp);
7504       rcall = builtin_save_expr (rcall);
7505       return fold_build2_loc (loc, COMPLEX_EXPR, type,
7506                           fold_build2_loc (loc, MULT_EXPR, rtype,
7507                                        rcall,
7508                                        fold_build1_loc (loc, REALPART_EXPR,
7509                                                     rtype, icall)),
7510                           fold_build2_loc (loc, MULT_EXPR, rtype,
7511                                        rcall,
7512                                        fold_build1_loc (loc, IMAGPART_EXPR,
7513                                                     rtype, icall)));
7514     }
7515
7516   return NULL_TREE;
7517 }
7518
7519 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7520    Return NULL_TREE if no simplification can be made.  */
7521
7522 static tree
7523 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7524 {
7525   if (!validate_arg (arg, REAL_TYPE))
7526     return NULL_TREE;
7527
7528   /* Optimize trunc of constant value.  */
7529   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7530     {
7531       REAL_VALUE_TYPE r, x;
7532       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7533
7534       x = TREE_REAL_CST (arg);
7535       real_trunc (&r, TYPE_MODE (type), &x);
7536       return build_real (type, r);
7537     }
7538
7539   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7540 }
7541
7542 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7543    Return NULL_TREE if no simplification can be made.  */
7544
7545 static tree
7546 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7547 {
7548   if (!validate_arg (arg, REAL_TYPE))
7549     return NULL_TREE;
7550
7551   /* Optimize floor of constant value.  */
7552   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7553     {
7554       REAL_VALUE_TYPE x;
7555
7556       x = TREE_REAL_CST (arg);
7557       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7558         {
7559           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7560           REAL_VALUE_TYPE r;
7561
7562           real_floor (&r, TYPE_MODE (type), &x);
7563           return build_real (type, r);
7564         }
7565     }
7566
7567   /* Fold floor (x) where x is nonnegative to trunc (x).  */
7568   if (tree_expr_nonnegative_p (arg))
7569     {
7570       tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7571       if (truncfn)
7572         return build_call_expr_loc (loc, truncfn, 1, arg);
7573     }
7574
7575   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7576 }
7577
7578 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7579    Return NULL_TREE if no simplification can be made.  */
7580
7581 static tree
7582 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7583 {
7584   if (!validate_arg (arg, REAL_TYPE))
7585     return NULL_TREE;
7586
7587   /* Optimize ceil of constant value.  */
7588   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7589     {
7590       REAL_VALUE_TYPE x;
7591
7592       x = TREE_REAL_CST (arg);
7593       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7594         {
7595           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7596           REAL_VALUE_TYPE r;
7597
7598           real_ceil (&r, TYPE_MODE (type), &x);
7599           return build_real (type, r);
7600         }
7601     }
7602
7603   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7604 }
7605
7606 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7607    Return NULL_TREE if no simplification can be made.  */
7608
7609 static tree
7610 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7611 {
7612   if (!validate_arg (arg, REAL_TYPE))
7613     return NULL_TREE;
7614
7615   /* Optimize round of constant value.  */
7616   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7617     {
7618       REAL_VALUE_TYPE x;
7619
7620       x = TREE_REAL_CST (arg);
7621       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7622         {
7623           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7624           REAL_VALUE_TYPE r;
7625
7626           real_round (&r, TYPE_MODE (type), &x);
7627           return build_real (type, r);
7628         }
7629     }
7630
7631   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7632 }
7633
7634 /* Fold function call to builtin lround, lroundf or lroundl (or the
7635    corresponding long long versions) and other rounding functions.  ARG
7636    is the argument to the call.  Return NULL_TREE if no simplification
7637    can be made.  */
7638
7639 static tree
7640 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7641 {
7642   if (!validate_arg (arg, REAL_TYPE))
7643     return NULL_TREE;
7644
7645   /* Optimize lround of constant value.  */
7646   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7647     {
7648       const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7649
7650       if (real_isfinite (&x))
7651         {
7652           tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7653           tree ftype = TREE_TYPE (arg);
7654           double_int val;
7655           REAL_VALUE_TYPE r;
7656
7657           switch (DECL_FUNCTION_CODE (fndecl))
7658             {
7659             CASE_FLT_FN (BUILT_IN_LFLOOR):
7660             CASE_FLT_FN (BUILT_IN_LLFLOOR):
7661               real_floor (&r, TYPE_MODE (ftype), &x);
7662               break;
7663
7664             CASE_FLT_FN (BUILT_IN_LCEIL):
7665             CASE_FLT_FN (BUILT_IN_LLCEIL):
7666               real_ceil (&r, TYPE_MODE (ftype), &x);
7667               break;
7668
7669             CASE_FLT_FN (BUILT_IN_LROUND):
7670             CASE_FLT_FN (BUILT_IN_LLROUND):
7671               real_round (&r, TYPE_MODE (ftype), &x);
7672               break;
7673
7674             default:
7675               gcc_unreachable ();
7676             }
7677
7678           real_to_integer2 ((HOST_WIDE_INT *)&val.low, &val.high, &r);
7679           if (double_int_fits_to_tree_p (itype, val))
7680             return double_int_to_tree (itype, val);
7681         }
7682     }
7683
7684   switch (DECL_FUNCTION_CODE (fndecl))
7685     {
7686     CASE_FLT_FN (BUILT_IN_LFLOOR):
7687     CASE_FLT_FN (BUILT_IN_LLFLOOR):
7688       /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x).  */
7689       if (tree_expr_nonnegative_p (arg))
7690         return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7691                             TREE_TYPE (TREE_TYPE (fndecl)), arg);
7692       break;
7693     default:;
7694     }
7695
7696   return fold_fixed_mathfn (loc, fndecl, arg);
7697 }
7698
7699 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7700    and their long and long long variants (i.e. ffsl and ffsll).  ARG is
7701    the argument to the call.  Return NULL_TREE if no simplification can
7702    be made.  */
7703
7704 static tree
7705 fold_builtin_bitop (tree fndecl, tree arg)
7706 {
7707   if (!validate_arg (arg, INTEGER_TYPE))
7708     return NULL_TREE;
7709
7710   /* Optimize for constant argument.  */
7711   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7712     {
7713       HOST_WIDE_INT hi, width, result;
7714       unsigned HOST_WIDE_INT lo;
7715       tree type;
7716
7717       type = TREE_TYPE (arg);
7718       width = TYPE_PRECISION (type);
7719       lo = TREE_INT_CST_LOW (arg);
7720
7721       /* Clear all the bits that are beyond the type's precision.  */
7722       if (width > HOST_BITS_PER_WIDE_INT)
7723         {
7724           hi = TREE_INT_CST_HIGH (arg);
7725           if (width < 2 * HOST_BITS_PER_WIDE_INT)
7726             hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7727         }
7728       else
7729         {
7730           hi = 0;
7731           if (width < HOST_BITS_PER_WIDE_INT)
7732             lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7733         }
7734
7735       switch (DECL_FUNCTION_CODE (fndecl))
7736         {
7737         CASE_INT_FN (BUILT_IN_FFS):
7738           if (lo != 0)
7739             result = ffs_hwi (lo);
7740           else if (hi != 0)
7741             result = HOST_BITS_PER_WIDE_INT + ffs_hwi (hi);
7742           else
7743             result = 0;
7744           break;
7745
7746         CASE_INT_FN (BUILT_IN_CLZ):
7747           if (hi != 0)
7748             result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7749           else if (lo != 0)
7750             result = width - floor_log2 (lo) - 1;
7751           else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7752             result = width;
7753           break;
7754
7755         CASE_INT_FN (BUILT_IN_CTZ):
7756           if (lo != 0)
7757             result = ctz_hwi (lo);
7758           else if (hi != 0)
7759             result = HOST_BITS_PER_WIDE_INT + ctz_hwi (hi);
7760           else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7761             result = width;
7762           break;
7763
7764         CASE_INT_FN (BUILT_IN_POPCOUNT):
7765           result = 0;
7766           while (lo)
7767             result++, lo &= lo - 1;
7768           while (hi)
7769             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7770           break;
7771
7772         CASE_INT_FN (BUILT_IN_PARITY):
7773           result = 0;
7774           while (lo)
7775             result++, lo &= lo - 1;
7776           while (hi)
7777             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7778           result &= 1;
7779           break;
7780
7781         default:
7782           gcc_unreachable ();
7783         }
7784
7785       return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7786     }
7787
7788   return NULL_TREE;
7789 }
7790
7791 /* Fold function call to builtin_bswap and the long and long long
7792    variants.  Return NULL_TREE if no simplification can be made.  */
7793 static tree
7794 fold_builtin_bswap (tree fndecl, tree arg)
7795 {
7796   if (! validate_arg (arg, INTEGER_TYPE))
7797     return NULL_TREE;
7798
7799   /* Optimize constant value.  */
7800   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7801     {
7802       HOST_WIDE_INT hi, width, r_hi = 0;
7803       unsigned HOST_WIDE_INT lo, r_lo = 0;
7804       tree type;
7805
7806       type = TREE_TYPE (arg);
7807       width = TYPE_PRECISION (type);
7808       lo = TREE_INT_CST_LOW (arg);
7809       hi = TREE_INT_CST_HIGH (arg);
7810
7811       switch (DECL_FUNCTION_CODE (fndecl))
7812         {
7813           case BUILT_IN_BSWAP32:
7814           case BUILT_IN_BSWAP64:
7815             {
7816               int s;
7817
7818               for (s = 0; s < width; s += 8)
7819                 {
7820                   int d = width - s - 8;
7821                   unsigned HOST_WIDE_INT byte;
7822
7823                   if (s < HOST_BITS_PER_WIDE_INT)
7824                     byte = (lo >> s) & 0xff;
7825                   else
7826                     byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
7827
7828                   if (d < HOST_BITS_PER_WIDE_INT)
7829                     r_lo |= byte << d;
7830                   else
7831                     r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
7832                 }
7833             }
7834
7835             break;
7836
7837         default:
7838           gcc_unreachable ();
7839         }
7840
7841       if (width < HOST_BITS_PER_WIDE_INT)
7842         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
7843       else
7844         return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
7845     }
7846
7847   return NULL_TREE;
7848 }
7849
7850 /* A subroutine of fold_builtin to fold the various logarithmic
7851    functions.  Return NULL_TREE if no simplification can me made.
7852    FUNC is the corresponding MPFR logarithm function.  */
7853
7854 static tree
7855 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
7856                         int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
7857 {
7858   if (validate_arg (arg, REAL_TYPE))
7859     {
7860       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7861       tree res;
7862       const enum built_in_function fcode = builtin_mathfn_code (arg);
7863
7864       /* Calculate the result when the argument is a constant.  */
7865       if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
7866         return res;
7867
7868       /* Special case, optimize logN(expN(x)) = x.  */
7869       if (flag_unsafe_math_optimizations
7870           && ((func == mpfr_log
7871                && (fcode == BUILT_IN_EXP
7872                    || fcode == BUILT_IN_EXPF
7873                    || fcode == BUILT_IN_EXPL))
7874               || (func == mpfr_log2
7875                   && (fcode == BUILT_IN_EXP2
7876                       || fcode == BUILT_IN_EXP2F
7877                       || fcode == BUILT_IN_EXP2L))
7878               || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
7879         return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
7880
7881       /* Optimize logN(func()) for various exponential functions.  We
7882          want to determine the value "x" and the power "exponent" in
7883          order to transform logN(x**exponent) into exponent*logN(x).  */
7884       if (flag_unsafe_math_optimizations)
7885         {
7886           tree exponent = 0, x = 0;
7887
7888           switch (fcode)
7889           {
7890           CASE_FLT_FN (BUILT_IN_EXP):
7891             /* Prepare to do logN(exp(exponent) -> exponent*logN(e).  */
7892             x = build_real (type, real_value_truncate (TYPE_MODE (type),
7893                                                        dconst_e ()));
7894             exponent = CALL_EXPR_ARG (arg, 0);
7895             break;
7896           CASE_FLT_FN (BUILT_IN_EXP2):
7897             /* Prepare to do logN(exp2(exponent) -> exponent*logN(2).  */
7898             x = build_real (type, dconst2);
7899             exponent = CALL_EXPR_ARG (arg, 0);
7900             break;
7901           CASE_FLT_FN (BUILT_IN_EXP10):
7902           CASE_FLT_FN (BUILT_IN_POW10):
7903             /* Prepare to do logN(exp10(exponent) -> exponent*logN(10).  */
7904             {
7905               REAL_VALUE_TYPE dconst10;
7906               real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
7907               x = build_real (type, dconst10);
7908             }
7909             exponent = CALL_EXPR_ARG (arg, 0);
7910             break;
7911           CASE_FLT_FN (BUILT_IN_SQRT):
7912             /* Prepare to do logN(sqrt(x) -> 0.5*logN(x).  */
7913             x = CALL_EXPR_ARG (arg, 0);
7914             exponent = build_real (type, dconsthalf);
7915             break;
7916           CASE_FLT_FN (BUILT_IN_CBRT):
7917             /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x).  */
7918             x = CALL_EXPR_ARG (arg, 0);
7919             exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
7920                                                               dconst_third ()));
7921             break;
7922           CASE_FLT_FN (BUILT_IN_POW):
7923             /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x).  */
7924             x = CALL_EXPR_ARG (arg, 0);
7925             exponent = CALL_EXPR_ARG (arg, 1);
7926             break;
7927           default:
7928             break;
7929           }
7930
7931           /* Now perform the optimization.  */
7932           if (x && exponent)
7933             {
7934               tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
7935               return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
7936             }
7937         }
7938     }
7939
7940   return NULL_TREE;
7941 }
7942
7943 /* Fold a builtin function call to hypot, hypotf, or hypotl.  Return
7944    NULL_TREE if no simplification can be made.  */
7945
7946 static tree
7947 fold_builtin_hypot (location_t loc, tree fndecl,
7948                     tree arg0, tree arg1, tree type)
7949 {
7950   tree res, narg0, narg1;
7951
7952   if (!validate_arg (arg0, REAL_TYPE)
7953       || !validate_arg (arg1, REAL_TYPE))
7954     return NULL_TREE;
7955
7956   /* Calculate the result when the argument is a constant.  */
7957   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
7958     return res;
7959
7960   /* If either argument to hypot has a negate or abs, strip that off.
7961      E.g. hypot(-x,fabs(y)) -> hypot(x,y).  */
7962   narg0 = fold_strip_sign_ops (arg0);
7963   narg1 = fold_strip_sign_ops (arg1);
7964   if (narg0 || narg1)
7965     {
7966       return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
7967                               narg1 ? narg1 : arg1);
7968     }
7969
7970   /* If either argument is zero, hypot is fabs of the other.  */
7971   if (real_zerop (arg0))
7972     return fold_build1_loc (loc, ABS_EXPR, type, arg1);
7973   else if (real_zerop (arg1))
7974     return fold_build1_loc (loc, ABS_EXPR, type, arg0);
7975
7976   /* hypot(x,x) -> fabs(x)*sqrt(2).  */
7977   if (flag_unsafe_math_optimizations
7978       && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
7979     {
7980       const REAL_VALUE_TYPE sqrt2_trunc
7981         = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7982       return fold_build2_loc (loc, MULT_EXPR, type,
7983                           fold_build1_loc (loc, ABS_EXPR, type, arg0),
7984                           build_real (type, sqrt2_trunc));
7985     }
7986
7987   return NULL_TREE;
7988 }
7989
7990
7991 /* Fold a builtin function call to pow, powf, or powl.  Return
7992    NULL_TREE if no simplification can be made.  */
7993 static tree
7994 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
7995 {
7996   tree res;
7997
7998   if (!validate_arg (arg0, REAL_TYPE)
7999        || !validate_arg (arg1, REAL_TYPE))
8000     return NULL_TREE;
8001
8002   /* Calculate the result when the argument is a constant.  */
8003   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8004     return res;
8005
8006   /* Optimize pow(1.0,y) = 1.0.  */
8007   if (real_onep (arg0))
8008     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8009
8010   if (TREE_CODE (arg1) == REAL_CST
8011       && !TREE_OVERFLOW (arg1))
8012     {
8013       REAL_VALUE_TYPE cint;
8014       REAL_VALUE_TYPE c;
8015       HOST_WIDE_INT n;
8016
8017       c = TREE_REAL_CST (arg1);
8018
8019       /* Optimize pow(x,0.0) = 1.0.  */
8020       if (REAL_VALUES_EQUAL (c, dconst0))
8021         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8022                                  arg0);
8023
8024       /* Optimize pow(x,1.0) = x.  */
8025       if (REAL_VALUES_EQUAL (c, dconst1))
8026         return arg0;
8027
8028       /* Optimize pow(x,-1.0) = 1.0/x.  */
8029       if (REAL_VALUES_EQUAL (c, dconstm1))
8030         return fold_build2_loc (loc, RDIV_EXPR, type,
8031                             build_real (type, dconst1), arg0);
8032
8033       /* Optimize pow(x,0.5) = sqrt(x).  */
8034       if (flag_unsafe_math_optimizations
8035           && REAL_VALUES_EQUAL (c, dconsthalf))
8036         {
8037           tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8038
8039           if (sqrtfn != NULL_TREE)
8040             return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8041         }
8042
8043       /* Optimize pow(x,1.0/3.0) = cbrt(x).  */
8044       if (flag_unsafe_math_optimizations)
8045         {
8046           const REAL_VALUE_TYPE dconstroot
8047             = real_value_truncate (TYPE_MODE (type), dconst_third ());
8048
8049           if (REAL_VALUES_EQUAL (c, dconstroot))
8050             {
8051               tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8052               if (cbrtfn != NULL_TREE)
8053                 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8054             }
8055         }
8056
8057       /* Check for an integer exponent.  */
8058       n = real_to_integer (&c);
8059       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8060       if (real_identical (&c, &cint))
8061         {
8062           /* Attempt to evaluate pow at compile-time, unless this should
8063              raise an exception.  */
8064           if (TREE_CODE (arg0) == REAL_CST
8065               && !TREE_OVERFLOW (arg0)
8066               && (n > 0
8067                   || (!flag_trapping_math && !flag_errno_math)
8068                   || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8069             {
8070               REAL_VALUE_TYPE x;
8071               bool inexact;
8072
8073               x = TREE_REAL_CST (arg0);
8074               inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8075               if (flag_unsafe_math_optimizations || !inexact)
8076                 return build_real (type, x);
8077             }
8078
8079           /* Strip sign ops from even integer powers.  */
8080           if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8081             {
8082               tree narg0 = fold_strip_sign_ops (arg0);
8083               if (narg0)
8084                 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8085             }
8086         }
8087     }
8088
8089   if (flag_unsafe_math_optimizations)
8090     {
8091       const enum built_in_function fcode = builtin_mathfn_code (arg0);
8092
8093       /* Optimize pow(expN(x),y) = expN(x*y).  */
8094       if (BUILTIN_EXPONENT_P (fcode))
8095         {
8096           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8097           tree arg = CALL_EXPR_ARG (arg0, 0);
8098           arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8099           return build_call_expr_loc (loc, expfn, 1, arg);
8100         }
8101
8102       /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
8103       if (BUILTIN_SQRT_P (fcode))
8104         {
8105           tree narg0 = CALL_EXPR_ARG (arg0, 0);
8106           tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8107                                     build_real (type, dconsthalf));
8108           return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8109         }
8110
8111       /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative.  */
8112       if (BUILTIN_CBRT_P (fcode))
8113         {
8114           tree arg = CALL_EXPR_ARG (arg0, 0);
8115           if (tree_expr_nonnegative_p (arg))
8116             {
8117               const REAL_VALUE_TYPE dconstroot
8118                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8119               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8120                                         build_real (type, dconstroot));
8121               return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8122             }
8123         }
8124
8125       /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative.  */
8126       if (fcode == BUILT_IN_POW
8127           || fcode == BUILT_IN_POWF
8128           || fcode == BUILT_IN_POWL)
8129         {
8130           tree arg00 = CALL_EXPR_ARG (arg0, 0);
8131           if (tree_expr_nonnegative_p (arg00))
8132             {
8133               tree arg01 = CALL_EXPR_ARG (arg0, 1);
8134               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8135               return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8136             }
8137         }
8138     }
8139
8140   return NULL_TREE;
8141 }
8142
8143 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8144    Return NULL_TREE if no simplification can be made.  */
8145 static tree
8146 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8147                    tree arg0, tree arg1, tree type)
8148 {
8149   if (!validate_arg (arg0, REAL_TYPE)
8150       || !validate_arg (arg1, INTEGER_TYPE))
8151     return NULL_TREE;
8152
8153   /* Optimize pow(1.0,y) = 1.0.  */
8154   if (real_onep (arg0))
8155     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8156
8157   if (host_integerp (arg1, 0))
8158     {
8159       HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8160
8161       /* Evaluate powi at compile-time.  */
8162       if (TREE_CODE (arg0) == REAL_CST
8163           && !TREE_OVERFLOW (arg0))
8164         {
8165           REAL_VALUE_TYPE x;
8166           x = TREE_REAL_CST (arg0);
8167           real_powi (&x, TYPE_MODE (type), &x, c);
8168           return build_real (type, x);
8169         }
8170
8171       /* Optimize pow(x,0) = 1.0.  */
8172       if (c == 0)
8173         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8174                                  arg0);
8175
8176       /* Optimize pow(x,1) = x.  */
8177       if (c == 1)
8178         return arg0;
8179
8180       /* Optimize pow(x,-1) = 1.0/x.  */
8181       if (c == -1)
8182         return fold_build2_loc (loc, RDIV_EXPR, type,
8183                            build_real (type, dconst1), arg0);
8184     }
8185
8186   return NULL_TREE;
8187 }
8188
8189 /* A subroutine of fold_builtin to fold the various exponent
8190    functions.  Return NULL_TREE if no simplification can be made.
8191    FUNC is the corresponding MPFR exponent function.  */
8192
8193 static tree
8194 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8195                        int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8196 {
8197   if (validate_arg (arg, REAL_TYPE))
8198     {
8199       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8200       tree res;
8201
8202       /* Calculate the result when the argument is a constant.  */
8203       if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8204         return res;
8205
8206       /* Optimize expN(logN(x)) = x.  */
8207       if (flag_unsafe_math_optimizations)
8208         {
8209           const enum built_in_function fcode = builtin_mathfn_code (arg);
8210
8211           if ((func == mpfr_exp
8212                && (fcode == BUILT_IN_LOG
8213                    || fcode == BUILT_IN_LOGF
8214                    || fcode == BUILT_IN_LOGL))
8215               || (func == mpfr_exp2
8216                   && (fcode == BUILT_IN_LOG2
8217                       || fcode == BUILT_IN_LOG2F
8218                       || fcode == BUILT_IN_LOG2L))
8219               || (func == mpfr_exp10
8220                   && (fcode == BUILT_IN_LOG10
8221                       || fcode == BUILT_IN_LOG10F
8222                       || fcode == BUILT_IN_LOG10L)))
8223             return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8224         }
8225     }
8226
8227   return NULL_TREE;
8228 }
8229
8230 /* Return true if VAR is a VAR_DECL or a component thereof.  */
8231
8232 static bool
8233 var_decl_component_p (tree var)
8234 {
8235   tree inner = var;
8236   while (handled_component_p (inner))
8237     inner = TREE_OPERAND (inner, 0);
8238   return SSA_VAR_P (inner);
8239 }
8240
8241 /* Fold function call to builtin memset.  Return
8242    NULL_TREE if no simplification can be made.  */
8243
8244 static tree
8245 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8246                      tree type, bool ignore)
8247 {
8248   tree var, ret, etype;
8249   unsigned HOST_WIDE_INT length, cval;
8250
8251   if (! validate_arg (dest, POINTER_TYPE)
8252       || ! validate_arg (c, INTEGER_TYPE)
8253       || ! validate_arg (len, INTEGER_TYPE))
8254     return NULL_TREE;
8255
8256   if (! host_integerp (len, 1))
8257     return NULL_TREE;
8258
8259   /* If the LEN parameter is zero, return DEST.  */
8260   if (integer_zerop (len))
8261     return omit_one_operand_loc (loc, type, dest, c);
8262
8263   if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
8264     return NULL_TREE;
8265
8266   var = dest;
8267   STRIP_NOPS (var);
8268   if (TREE_CODE (var) != ADDR_EXPR)
8269     return NULL_TREE;
8270
8271   var = TREE_OPERAND (var, 0);
8272   if (TREE_THIS_VOLATILE (var))
8273     return NULL_TREE;
8274
8275   etype = TREE_TYPE (var);
8276   if (TREE_CODE (etype) == ARRAY_TYPE)
8277     etype = TREE_TYPE (etype);
8278
8279   if (!INTEGRAL_TYPE_P (etype)
8280       && !POINTER_TYPE_P (etype))
8281     return NULL_TREE;
8282
8283   if (! var_decl_component_p (var))
8284     return NULL_TREE;
8285
8286   length = tree_low_cst (len, 1);
8287   if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8288       || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8289          < length)
8290     return NULL_TREE;
8291
8292   if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8293     return NULL_TREE;
8294
8295   if (integer_zerop (c))
8296     cval = 0;
8297   else
8298     {
8299       if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8300         return NULL_TREE;
8301
8302       cval = tree_low_cst (c, 1);
8303       cval &= 0xff;
8304       cval |= cval << 8;
8305       cval |= cval << 16;
8306       cval |= (cval << 31) << 1;
8307     }
8308
8309   ret = build_int_cst_type (etype, cval);
8310   var = build_fold_indirect_ref_loc (loc,
8311                                  fold_convert_loc (loc,
8312                                                    build_pointer_type (etype),
8313                                                    dest));
8314   ret = build2 (MODIFY_EXPR, etype, var, ret);
8315   if (ignore)
8316     return ret;
8317
8318   return omit_one_operand_loc (loc, type, dest, ret);
8319 }
8320
8321 /* Fold function call to builtin memset.  Return
8322    NULL_TREE if no simplification can be made.  */
8323
8324 static tree
8325 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8326 {
8327   if (! validate_arg (dest, POINTER_TYPE)
8328       || ! validate_arg (size, INTEGER_TYPE))
8329     return NULL_TREE;
8330
8331   if (!ignore)
8332     return NULL_TREE;
8333
8334   /* New argument list transforming bzero(ptr x, int y) to
8335      memset(ptr x, int 0, size_t y).   This is done this way
8336      so that if it isn't expanded inline, we fallback to
8337      calling bzero instead of memset.  */
8338
8339   return fold_builtin_memset (loc, dest, integer_zero_node,
8340                               fold_convert_loc (loc, sizetype, size),
8341                               void_type_node, ignore);
8342 }
8343
8344 /* Fold function call to builtin mem{{,p}cpy,move}.  Return
8345    NULL_TREE if no simplification can be made.
8346    If ENDP is 0, return DEST (like memcpy).
8347    If ENDP is 1, return DEST+LEN (like mempcpy).
8348    If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8349    If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8350    (memmove).   */
8351
8352 static tree
8353 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8354                         tree len, tree type, bool ignore, int endp)
8355 {
8356   tree destvar, srcvar, expr;
8357
8358   if (! validate_arg (dest, POINTER_TYPE)
8359       || ! validate_arg (src, POINTER_TYPE)
8360       || ! validate_arg (len, INTEGER_TYPE))
8361     return NULL_TREE;
8362
8363   /* If the LEN parameter is zero, return DEST.  */
8364   if (integer_zerop (len))
8365     return omit_one_operand_loc (loc, type, dest, src);
8366
8367   /* If SRC and DEST are the same (and not volatile), return
8368      DEST{,+LEN,+LEN-1}.  */
8369   if (operand_equal_p (src, dest, 0))
8370     expr = len;
8371   else
8372     {
8373       tree srctype, desttype;
8374       unsigned int src_align, dest_align;
8375       tree off0;
8376
8377       if (endp == 3)
8378         {
8379           src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8380           dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8381
8382           /* Both DEST and SRC must be pointer types.
8383              ??? This is what old code did.  Is the testing for pointer types
8384              really mandatory?
8385
8386              If either SRC is readonly or length is 1, we can use memcpy.  */
8387           if (!dest_align || !src_align)
8388             return NULL_TREE;
8389           if (readonly_data_expr (src)
8390               || (host_integerp (len, 1)
8391                   && (MIN (src_align, dest_align) / BITS_PER_UNIT
8392                       >= (unsigned HOST_WIDE_INT) tree_low_cst (len, 1))))
8393             {
8394               tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8395               if (!fn)
8396                 return NULL_TREE;
8397               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8398             }
8399
8400           /* If *src and *dest can't overlap, optimize into memcpy as well.  */
8401           if (TREE_CODE (src) == ADDR_EXPR
8402               && TREE_CODE (dest) == ADDR_EXPR)
8403             {
8404               tree src_base, dest_base, fn;
8405               HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8406               HOST_WIDE_INT size = -1;
8407               HOST_WIDE_INT maxsize = -1;
8408
8409               srcvar = TREE_OPERAND (src, 0);
8410               src_base = get_ref_base_and_extent (srcvar, &src_offset,
8411                                                   &size, &maxsize);
8412               destvar = TREE_OPERAND (dest, 0);
8413               dest_base = get_ref_base_and_extent (destvar, &dest_offset,
8414                                                    &size, &maxsize);
8415               if (host_integerp (len, 1))
8416                 maxsize = tree_low_cst (len, 1);
8417               else
8418                 maxsize = -1;
8419               src_offset /= BITS_PER_UNIT;
8420               dest_offset /= BITS_PER_UNIT;
8421               if (SSA_VAR_P (src_base)
8422                   && SSA_VAR_P (dest_base))
8423                 {
8424                   if (operand_equal_p (src_base, dest_base, 0)
8425                       && ranges_overlap_p (src_offset, maxsize,
8426                                            dest_offset, maxsize))
8427                     return NULL_TREE;
8428                 }
8429               else if (TREE_CODE (src_base) == MEM_REF
8430                        && TREE_CODE (dest_base) == MEM_REF)
8431                 {
8432                   double_int off;
8433                   if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8434                                          TREE_OPERAND (dest_base, 0), 0))
8435                     return NULL_TREE;
8436                   off = double_int_add (mem_ref_offset (src_base),
8437                                         shwi_to_double_int (src_offset));
8438                   if (!double_int_fits_in_shwi_p (off))
8439                     return NULL_TREE;
8440                   src_offset = off.low;
8441                   off = double_int_add (mem_ref_offset (dest_base),
8442                                         shwi_to_double_int (dest_offset));
8443                   if (!double_int_fits_in_shwi_p (off))
8444                     return NULL_TREE;
8445                   dest_offset = off.low;
8446                   if (ranges_overlap_p (src_offset, maxsize,
8447                                         dest_offset, maxsize))
8448                     return NULL_TREE;
8449                 }
8450               else
8451                 return NULL_TREE;
8452
8453               fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8454               if (!fn)
8455                 return NULL_TREE;
8456               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8457             }
8458
8459           /* If the destination and source do not alias optimize into
8460              memcpy as well.  */
8461           if ((is_gimple_min_invariant (dest)
8462                || TREE_CODE (dest) == SSA_NAME)
8463               && (is_gimple_min_invariant (src)
8464                   || TREE_CODE (src) == SSA_NAME))
8465             {
8466               ao_ref destr, srcr;
8467               ao_ref_init_from_ptr_and_size (&destr, dest, len);
8468               ao_ref_init_from_ptr_and_size (&srcr, src, len);
8469               if (!refs_may_alias_p_1 (&destr, &srcr, false))
8470                 {
8471                   tree fn;
8472                   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8473                   if (!fn)
8474                     return NULL_TREE;
8475                   return build_call_expr_loc (loc, fn, 3, dest, src, len);
8476                 }
8477             }
8478
8479           return NULL_TREE;
8480         }
8481
8482       if (!host_integerp (len, 0))
8483         return NULL_TREE;
8484       /* FIXME:
8485          This logic lose for arguments like (type *)malloc (sizeof (type)),
8486          since we strip the casts of up to VOID return value from malloc.
8487          Perhaps we ought to inherit type from non-VOID argument here?  */
8488       STRIP_NOPS (src);
8489       STRIP_NOPS (dest);
8490       /* As we fold (void *)(p + CST) to (void *)p + CST undo this here.  */
8491       if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8492         {
8493           tree tem = TREE_OPERAND (src, 0);
8494           STRIP_NOPS (tem);
8495           if (tem != TREE_OPERAND (src, 0))
8496             src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8497         }
8498       if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8499         {
8500           tree tem = TREE_OPERAND (dest, 0);
8501           STRIP_NOPS (tem);
8502           if (tem != TREE_OPERAND (dest, 0))
8503             dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8504         }
8505       srctype = TREE_TYPE (TREE_TYPE (src));
8506       if (srctype
8507           && TREE_CODE (srctype) == ARRAY_TYPE
8508           && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8509         {
8510           srctype = TREE_TYPE (srctype);
8511           STRIP_NOPS (src);
8512           src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8513         }
8514       desttype = TREE_TYPE (TREE_TYPE (dest));
8515       if (desttype
8516           && TREE_CODE (desttype) == ARRAY_TYPE
8517           && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8518         {
8519           desttype = TREE_TYPE (desttype);
8520           STRIP_NOPS (dest);
8521           dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8522         }
8523       if (!srctype || !desttype
8524           || TREE_ADDRESSABLE (srctype)
8525           || TREE_ADDRESSABLE (desttype)
8526           || !TYPE_SIZE_UNIT (srctype)
8527           || !TYPE_SIZE_UNIT (desttype)
8528           || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
8529           || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST)
8530         return NULL_TREE;
8531
8532       src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8533       dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8534       if (dest_align < TYPE_ALIGN (desttype)
8535           || src_align < TYPE_ALIGN (srctype))
8536         return NULL_TREE;
8537
8538       if (!ignore)
8539         dest = builtin_save_expr (dest);
8540
8541       /* Build accesses at offset zero with a ref-all character type.  */
8542       off0 = build_int_cst (build_pointer_type_for_mode (char_type_node,
8543                                                          ptr_mode, true), 0);
8544
8545       destvar = dest;
8546       STRIP_NOPS (destvar);
8547       if (TREE_CODE (destvar) == ADDR_EXPR
8548           && var_decl_component_p (TREE_OPERAND (destvar, 0))
8549           && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8550         destvar = fold_build2 (MEM_REF, desttype, destvar, off0);
8551       else
8552         destvar = NULL_TREE;
8553
8554       srcvar = src;
8555       STRIP_NOPS (srcvar);
8556       if (TREE_CODE (srcvar) == ADDR_EXPR
8557           && var_decl_component_p (TREE_OPERAND (srcvar, 0))
8558           && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len)
8559           && (!STRICT_ALIGNMENT
8560               || !destvar
8561               || src_align >= TYPE_ALIGN (desttype)))
8562         srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype,
8563                               srcvar, off0);
8564       else
8565         srcvar = NULL_TREE;
8566
8567       if (srcvar == NULL_TREE && destvar == NULL_TREE)
8568         return NULL_TREE;
8569
8570       if (srcvar == NULL_TREE)
8571         {
8572           if (STRICT_ALIGNMENT
8573               && src_align < TYPE_ALIGN (desttype))
8574             return NULL_TREE;
8575           STRIP_NOPS (src);
8576           srcvar = fold_build2 (MEM_REF, desttype, src, off0);
8577         }
8578       else if (destvar == NULL_TREE)
8579         {
8580           if (STRICT_ALIGNMENT
8581               && dest_align < TYPE_ALIGN (srctype))
8582             return NULL_TREE;
8583           STRIP_NOPS (dest);
8584           destvar = fold_build2 (MEM_REF, srctype, dest, off0);
8585         }
8586
8587       expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, srcvar);
8588     }
8589
8590   if (ignore)
8591     return expr;
8592
8593   if (endp == 0 || endp == 3)
8594     return omit_one_operand_loc (loc, type, dest, expr);
8595
8596   if (expr == len)
8597     expr = NULL_TREE;
8598
8599   if (endp == 2)
8600     len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
8601                        ssize_int (1));
8602
8603   len = fold_convert_loc (loc, sizetype, len);
8604   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8605   dest = fold_convert_loc (loc, type, dest);
8606   if (expr)
8607     dest = omit_one_operand_loc (loc, type, dest, expr);
8608   return dest;
8609 }
8610
8611 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8612    If LEN is not NULL, it represents the length of the string to be
8613    copied.  Return NULL_TREE if no simplification can be made.  */
8614
8615 tree
8616 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
8617 {
8618   tree fn;
8619
8620   if (!validate_arg (dest, POINTER_TYPE)
8621       || !validate_arg (src, POINTER_TYPE))
8622     return NULL_TREE;
8623
8624   /* If SRC and DEST are the same (and not volatile), return DEST.  */
8625   if (operand_equal_p (src, dest, 0))
8626     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
8627
8628   if (optimize_function_for_size_p (cfun))
8629     return NULL_TREE;
8630
8631   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8632   if (!fn)
8633     return NULL_TREE;
8634
8635   if (!len)
8636     {
8637       len = c_strlen (src, 1);
8638       if (! len || TREE_SIDE_EFFECTS (len))
8639         return NULL_TREE;
8640     }
8641
8642   len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8643   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8644                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8645 }
8646
8647 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
8648    Return NULL_TREE if no simplification can be made.  */
8649
8650 static tree
8651 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
8652 {
8653   tree fn, len, lenp1, call, type;
8654
8655   if (!validate_arg (dest, POINTER_TYPE)
8656       || !validate_arg (src, POINTER_TYPE))
8657     return NULL_TREE;
8658
8659   len = c_strlen (src, 1);
8660   if (!len
8661       || TREE_CODE (len) != INTEGER_CST)
8662     return NULL_TREE;
8663
8664   if (optimize_function_for_size_p (cfun)
8665       /* If length is zero it's small enough.  */
8666       && !integer_zerop (len))
8667     return NULL_TREE;
8668
8669   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8670   if (!fn)
8671     return NULL_TREE;
8672
8673   lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8674   /* We use dest twice in building our expression.  Save it from
8675      multiple expansions.  */
8676   dest = builtin_save_expr (dest);
8677   call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
8678
8679   type = TREE_TYPE (TREE_TYPE (fndecl));
8680   len = fold_convert_loc (loc, sizetype, len);
8681   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8682   dest = fold_convert_loc (loc, type, dest);
8683   dest = omit_one_operand_loc (loc, type, dest, call);
8684   return dest;
8685 }
8686
8687 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8688    If SLEN is not NULL, it represents the length of the source string.
8689    Return NULL_TREE if no simplification can be made.  */
8690
8691 tree
8692 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
8693                       tree src, tree len, tree slen)
8694 {
8695   tree fn;
8696
8697   if (!validate_arg (dest, POINTER_TYPE)
8698       || !validate_arg (src, POINTER_TYPE)
8699       || !validate_arg (len, INTEGER_TYPE))
8700     return NULL_TREE;
8701
8702   /* If the LEN parameter is zero, return DEST.  */
8703   if (integer_zerop (len))
8704     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8705
8706   /* We can't compare slen with len as constants below if len is not a
8707      constant.  */
8708   if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8709     return NULL_TREE;
8710
8711   if (!slen)
8712     slen = c_strlen (src, 1);
8713
8714   /* Now, we must be passed a constant src ptr parameter.  */
8715   if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8716     return NULL_TREE;
8717
8718   slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
8719
8720   /* We do not support simplification of this case, though we do
8721      support it when expanding trees into RTL.  */
8722   /* FIXME: generate a call to __builtin_memset.  */
8723   if (tree_int_cst_lt (slen, len))
8724     return NULL_TREE;
8725
8726   /* OK transform into builtin memcpy.  */
8727   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8728   if (!fn)
8729     return NULL_TREE;
8730   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8731                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8732 }
8733
8734 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
8735    arguments to the call, and TYPE is its return type.
8736    Return NULL_TREE if no simplification can be made.  */
8737
8738 static tree
8739 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
8740 {
8741   if (!validate_arg (arg1, POINTER_TYPE)
8742       || !validate_arg (arg2, INTEGER_TYPE)
8743       || !validate_arg (len, INTEGER_TYPE))
8744     return NULL_TREE;
8745   else
8746     {
8747       const char *p1;
8748
8749       if (TREE_CODE (arg2) != INTEGER_CST
8750           || !host_integerp (len, 1))
8751         return NULL_TREE;
8752
8753       p1 = c_getstr (arg1);
8754       if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
8755         {
8756           char c;
8757           const char *r;
8758           tree tem;
8759
8760           if (target_char_cast (arg2, &c))
8761             return NULL_TREE;
8762
8763           r = (char *) memchr (p1, c, tree_low_cst (len, 1));
8764
8765           if (r == NULL)
8766             return build_int_cst (TREE_TYPE (arg1), 0);
8767
8768           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
8769                              size_int (r - p1));
8770           return fold_convert_loc (loc, type, tem);
8771         }
8772       return NULL_TREE;
8773     }
8774 }
8775
8776 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8777    Return NULL_TREE if no simplification can be made.  */
8778
8779 static tree
8780 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
8781 {
8782   const char *p1, *p2;
8783
8784   if (!validate_arg (arg1, POINTER_TYPE)
8785       || !validate_arg (arg2, POINTER_TYPE)
8786       || !validate_arg (len, INTEGER_TYPE))
8787     return NULL_TREE;
8788
8789   /* If the LEN parameter is zero, return zero.  */
8790   if (integer_zerop (len))
8791     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8792                               arg1, arg2);
8793
8794   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8795   if (operand_equal_p (arg1, arg2, 0))
8796     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8797
8798   p1 = c_getstr (arg1);
8799   p2 = c_getstr (arg2);
8800
8801   /* If all arguments are constant, and the value of len is not greater
8802      than the lengths of arg1 and arg2, evaluate at compile-time.  */
8803   if (host_integerp (len, 1) && p1 && p2
8804       && compare_tree_int (len, strlen (p1) + 1) <= 0
8805       && compare_tree_int (len, strlen (p2) + 1) <= 0)
8806     {
8807       const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8808
8809       if (r > 0)
8810         return integer_one_node;
8811       else if (r < 0)
8812         return integer_minus_one_node;
8813       else
8814         return integer_zero_node;
8815     }
8816
8817   /* If len parameter is one, return an expression corresponding to
8818      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
8819   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8820     {
8821       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8822       tree cst_uchar_ptr_node
8823         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8824
8825       tree ind1
8826         = fold_convert_loc (loc, integer_type_node,
8827                             build1 (INDIRECT_REF, cst_uchar_node,
8828                                     fold_convert_loc (loc,
8829                                                       cst_uchar_ptr_node,
8830                                                       arg1)));
8831       tree ind2
8832         = fold_convert_loc (loc, integer_type_node,
8833                             build1 (INDIRECT_REF, cst_uchar_node,
8834                                     fold_convert_loc (loc,
8835                                                       cst_uchar_ptr_node,
8836                                                       arg2)));
8837       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8838     }
8839
8840   return NULL_TREE;
8841 }
8842
8843 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8844    Return NULL_TREE if no simplification can be made.  */
8845
8846 static tree
8847 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
8848 {
8849   const char *p1, *p2;
8850
8851   if (!validate_arg (arg1, POINTER_TYPE)
8852       || !validate_arg (arg2, POINTER_TYPE))
8853     return NULL_TREE;
8854
8855   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8856   if (operand_equal_p (arg1, arg2, 0))
8857     return integer_zero_node;
8858
8859   p1 = c_getstr (arg1);
8860   p2 = c_getstr (arg2);
8861
8862   if (p1 && p2)
8863     {
8864       const int i = strcmp (p1, p2);
8865       if (i < 0)
8866         return integer_minus_one_node;
8867       else if (i > 0)
8868         return integer_one_node;
8869       else
8870         return integer_zero_node;
8871     }
8872
8873   /* If the second arg is "", return *(const unsigned char*)arg1.  */
8874   if (p2 && *p2 == '\0')
8875     {
8876       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8877       tree cst_uchar_ptr_node
8878         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8879
8880       return fold_convert_loc (loc, integer_type_node,
8881                                build1 (INDIRECT_REF, cst_uchar_node,
8882                                        fold_convert_loc (loc,
8883                                                          cst_uchar_ptr_node,
8884                                                          arg1)));
8885     }
8886
8887   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
8888   if (p1 && *p1 == '\0')
8889     {
8890       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8891       tree cst_uchar_ptr_node
8892         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8893
8894       tree temp
8895         = fold_convert_loc (loc, integer_type_node,
8896                             build1 (INDIRECT_REF, cst_uchar_node,
8897                                     fold_convert_loc (loc,
8898                                                       cst_uchar_ptr_node,
8899                                                       arg2)));
8900       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8901     }
8902
8903   return NULL_TREE;
8904 }
8905
8906 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
8907    Return NULL_TREE if no simplification can be made.  */
8908
8909 static tree
8910 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
8911 {
8912   const char *p1, *p2;
8913
8914   if (!validate_arg (arg1, POINTER_TYPE)
8915       || !validate_arg (arg2, POINTER_TYPE)
8916       || !validate_arg (len, INTEGER_TYPE))
8917     return NULL_TREE;
8918
8919   /* If the LEN parameter is zero, return zero.  */
8920   if (integer_zerop (len))
8921     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8922                               arg1, arg2);
8923
8924   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8925   if (operand_equal_p (arg1, arg2, 0))
8926     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8927
8928   p1 = c_getstr (arg1);
8929   p2 = c_getstr (arg2);
8930
8931   if (host_integerp (len, 1) && p1 && p2)
8932     {
8933       const int i = strncmp (p1, p2, tree_low_cst (len, 1));
8934       if (i > 0)
8935         return integer_one_node;
8936       else if (i < 0)
8937         return integer_minus_one_node;
8938       else
8939         return integer_zero_node;
8940     }
8941
8942   /* If the second arg is "", and the length is greater than zero,
8943      return *(const unsigned char*)arg1.  */
8944   if (p2 && *p2 == '\0'
8945       && TREE_CODE (len) == INTEGER_CST
8946       && tree_int_cst_sgn (len) == 1)
8947     {
8948       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8949       tree cst_uchar_ptr_node
8950         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8951
8952       return fold_convert_loc (loc, integer_type_node,
8953                                build1 (INDIRECT_REF, cst_uchar_node,
8954                                        fold_convert_loc (loc,
8955                                                          cst_uchar_ptr_node,
8956                                                          arg1)));
8957     }
8958
8959   /* If the first arg is "", and the length is greater than zero,
8960      return -*(const unsigned char*)arg2.  */
8961   if (p1 && *p1 == '\0'
8962       && TREE_CODE (len) == INTEGER_CST
8963       && tree_int_cst_sgn (len) == 1)
8964     {
8965       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8966       tree cst_uchar_ptr_node
8967         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8968
8969       tree temp = fold_convert_loc (loc, integer_type_node,
8970                                     build1 (INDIRECT_REF, cst_uchar_node,
8971                                             fold_convert_loc (loc,
8972                                                               cst_uchar_ptr_node,
8973                                                               arg2)));
8974       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8975     }
8976
8977   /* If len parameter is one, return an expression corresponding to
8978      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
8979   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8980     {
8981       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8982       tree cst_uchar_ptr_node
8983         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8984
8985       tree ind1 = fold_convert_loc (loc, integer_type_node,
8986                                     build1 (INDIRECT_REF, cst_uchar_node,
8987                                             fold_convert_loc (loc,
8988                                                               cst_uchar_ptr_node,
8989                                                               arg1)));
8990       tree ind2 = fold_convert_loc (loc, integer_type_node,
8991                                     build1 (INDIRECT_REF, cst_uchar_node,
8992                                             fold_convert_loc (loc,
8993                                                               cst_uchar_ptr_node,
8994                                                               arg2)));
8995       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8996     }
8997
8998   return NULL_TREE;
8999 }
9000
9001 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9002    ARG.  Return NULL_TREE if no simplification can be made.  */
9003
9004 static tree
9005 fold_builtin_signbit (location_t loc, tree arg, tree type)
9006 {
9007   tree temp;
9008
9009   if (!validate_arg (arg, REAL_TYPE))
9010     return NULL_TREE;
9011
9012   /* If ARG is a compile-time constant, determine the result.  */
9013   if (TREE_CODE (arg) == REAL_CST
9014       && !TREE_OVERFLOW (arg))
9015     {
9016       REAL_VALUE_TYPE c;
9017
9018       c = TREE_REAL_CST (arg);
9019       temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
9020       return fold_convert_loc (loc, type, temp);
9021     }
9022
9023   /* If ARG is non-negative, the result is always zero.  */
9024   if (tree_expr_nonnegative_p (arg))
9025     return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9026
9027   /* If ARG's format doesn't have signed zeros, return "arg < 0.0".  */
9028   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9029     return fold_build2_loc (loc, LT_EXPR, type, arg,
9030                         build_real (TREE_TYPE (arg), dconst0));
9031
9032   return NULL_TREE;
9033 }
9034
9035 /* Fold function call to builtin copysign, copysignf or copysignl with
9036    arguments ARG1 and ARG2.  Return NULL_TREE if no simplification can
9037    be made.  */
9038
9039 static tree
9040 fold_builtin_copysign (location_t loc, tree fndecl,
9041                        tree arg1, tree arg2, tree type)
9042 {
9043   tree tem;
9044
9045   if (!validate_arg (arg1, REAL_TYPE)
9046       || !validate_arg (arg2, REAL_TYPE))
9047     return NULL_TREE;
9048
9049   /* copysign(X,X) is X.  */
9050   if (operand_equal_p (arg1, arg2, 0))
9051     return fold_convert_loc (loc, type, arg1);
9052
9053   /* If ARG1 and ARG2 are compile-time constants, determine the result.  */
9054   if (TREE_CODE (arg1) == REAL_CST
9055       && TREE_CODE (arg2) == REAL_CST
9056       && !TREE_OVERFLOW (arg1)
9057       && !TREE_OVERFLOW (arg2))
9058     {
9059       REAL_VALUE_TYPE c1, c2;
9060
9061       c1 = TREE_REAL_CST (arg1);
9062       c2 = TREE_REAL_CST (arg2);
9063       /* c1.sign := c2.sign.  */
9064       real_copysign (&c1, &c2);
9065       return build_real (type, c1);
9066     }
9067
9068   /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9069      Remember to evaluate Y for side-effects.  */
9070   if (tree_expr_nonnegative_p (arg2))
9071     return omit_one_operand_loc (loc, type,
9072                              fold_build1_loc (loc, ABS_EXPR, type, arg1),
9073                              arg2);
9074
9075   /* Strip sign changing operations for the first argument.  */
9076   tem = fold_strip_sign_ops (arg1);
9077   if (tem)
9078     return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9079
9080   return NULL_TREE;
9081 }
9082
9083 /* Fold a call to builtin isascii with argument ARG.  */
9084
9085 static tree
9086 fold_builtin_isascii (location_t loc, tree arg)
9087 {
9088   if (!validate_arg (arg, INTEGER_TYPE))
9089     return NULL_TREE;
9090   else
9091     {
9092       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
9093       arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9094                          build_int_cst (NULL_TREE,
9095                                         ~ (unsigned HOST_WIDE_INT) 0x7f));
9096       return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9097                           arg, integer_zero_node);
9098     }
9099 }
9100
9101 /* Fold a call to builtin toascii with argument ARG.  */
9102
9103 static tree
9104 fold_builtin_toascii (location_t loc, tree arg)
9105 {
9106   if (!validate_arg (arg, INTEGER_TYPE))
9107     return NULL_TREE;
9108
9109   /* Transform toascii(c) -> (c & 0x7f).  */
9110   return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9111                       build_int_cst (NULL_TREE, 0x7f));
9112 }
9113
9114 /* Fold a call to builtin isdigit with argument ARG.  */
9115
9116 static tree
9117 fold_builtin_isdigit (location_t loc, tree arg)
9118 {
9119   if (!validate_arg (arg, INTEGER_TYPE))
9120     return NULL_TREE;
9121   else
9122     {
9123       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
9124       /* According to the C standard, isdigit is unaffected by locale.
9125          However, it definitely is affected by the target character set.  */
9126       unsigned HOST_WIDE_INT target_digit0
9127         = lang_hooks.to_target_charset ('0');
9128
9129       if (target_digit0 == 0)
9130         return NULL_TREE;
9131
9132       arg = fold_convert_loc (loc, unsigned_type_node, arg);
9133       arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9134                          build_int_cst (unsigned_type_node, target_digit0));
9135       return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9136                           build_int_cst (unsigned_type_node, 9));
9137     }
9138 }
9139
9140 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
9141
9142 static tree
9143 fold_builtin_fabs (location_t loc, tree arg, tree type)
9144 {
9145   if (!validate_arg (arg, REAL_TYPE))
9146     return NULL_TREE;
9147
9148   arg = fold_convert_loc (loc, type, arg);
9149   if (TREE_CODE (arg) == REAL_CST)
9150     return fold_abs_const (arg, type);
9151   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9152 }
9153
9154 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
9155
9156 static tree
9157 fold_builtin_abs (location_t loc, tree arg, tree type)
9158 {
9159   if (!validate_arg (arg, INTEGER_TYPE))
9160     return NULL_TREE;
9161
9162   arg = fold_convert_loc (loc, type, arg);
9163   if (TREE_CODE (arg) == INTEGER_CST)
9164     return fold_abs_const (arg, type);
9165   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9166 }
9167
9168 /* Fold a call to builtin fmin or fmax.  */
9169
9170 static tree
9171 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9172                         tree type, bool max)
9173 {
9174   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9175     {
9176       /* Calculate the result when the argument is a constant.  */
9177       tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9178
9179       if (res)
9180         return res;
9181
9182       /* If either argument is NaN, return the other one.  Avoid the
9183          transformation if we get (and honor) a signalling NaN.  Using
9184          omit_one_operand() ensures we create a non-lvalue.  */
9185       if (TREE_CODE (arg0) == REAL_CST
9186           && real_isnan (&TREE_REAL_CST (arg0))
9187           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9188               || ! TREE_REAL_CST (arg0).signalling))
9189         return omit_one_operand_loc (loc, type, arg1, arg0);
9190       if (TREE_CODE (arg1) == REAL_CST
9191           && real_isnan (&TREE_REAL_CST (arg1))
9192           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9193               || ! TREE_REAL_CST (arg1).signalling))
9194         return omit_one_operand_loc (loc, type, arg0, arg1);
9195
9196       /* Transform fmin/fmax(x,x) -> x.  */
9197       if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9198         return omit_one_operand_loc (loc, type, arg0, arg1);
9199
9200       /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR.  C99 requires these
9201          functions to return the numeric arg if the other one is NaN.
9202          These tree codes don't honor that, so only transform if
9203          -ffinite-math-only is set.  C99 doesn't require -0.0 to be
9204          handled, so we don't have to worry about it either.  */
9205       if (flag_finite_math_only)
9206         return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9207                             fold_convert_loc (loc, type, arg0),
9208                             fold_convert_loc (loc, type, arg1));
9209     }
9210   return NULL_TREE;
9211 }
9212
9213 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
9214
9215 static tree
9216 fold_builtin_carg (location_t loc, tree arg, tree type)
9217 {
9218   if (validate_arg (arg, COMPLEX_TYPE)
9219       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9220     {
9221       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9222
9223       if (atan2_fn)
9224         {
9225           tree new_arg = builtin_save_expr (arg);
9226           tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9227           tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9228           return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9229         }
9230     }
9231
9232   return NULL_TREE;
9233 }
9234
9235 /* Fold a call to builtin logb/ilogb.  */
9236
9237 static tree
9238 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9239 {
9240   if (! validate_arg (arg, REAL_TYPE))
9241     return NULL_TREE;
9242
9243   STRIP_NOPS (arg);
9244
9245   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9246     {
9247       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9248
9249       switch (value->cl)
9250       {
9251       case rvc_nan:
9252       case rvc_inf:
9253         /* If arg is Inf or NaN and we're logb, return it.  */
9254         if (TREE_CODE (rettype) == REAL_TYPE)
9255           return fold_convert_loc (loc, rettype, arg);
9256         /* Fall through... */
9257       case rvc_zero:
9258         /* Zero may set errno and/or raise an exception for logb, also
9259            for ilogb we don't know FP_ILOGB0.  */
9260         return NULL_TREE;
9261       case rvc_normal:
9262         /* For normal numbers, proceed iff radix == 2.  In GCC,
9263            normalized significands are in the range [0.5, 1.0).  We
9264            want the exponent as if they were [1.0, 2.0) so get the
9265            exponent and subtract 1.  */
9266         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9267           return fold_convert_loc (loc, rettype,
9268                                    build_int_cst (NULL_TREE,
9269                                                   REAL_EXP (value)-1));
9270         break;
9271       }
9272     }
9273
9274   return NULL_TREE;
9275 }
9276
9277 /* Fold a call to builtin significand, if radix == 2.  */
9278
9279 static tree
9280 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9281 {
9282   if (! validate_arg (arg, REAL_TYPE))
9283     return NULL_TREE;
9284
9285   STRIP_NOPS (arg);
9286
9287   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9288     {
9289       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9290
9291       switch (value->cl)
9292       {
9293       case rvc_zero:
9294       case rvc_nan:
9295       case rvc_inf:
9296         /* If arg is +-0, +-Inf or +-NaN, then return it.  */
9297         return fold_convert_loc (loc, rettype, arg);
9298       case rvc_normal:
9299         /* For normal numbers, proceed iff radix == 2.  */
9300         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9301           {
9302             REAL_VALUE_TYPE result = *value;
9303             /* In GCC, normalized significands are in the range [0.5,
9304                1.0).  We want them to be [1.0, 2.0) so set the
9305                exponent to 1.  */
9306             SET_REAL_EXP (&result, 1);
9307             return build_real (rettype, result);
9308           }
9309         break;
9310       }
9311     }
9312
9313   return NULL_TREE;
9314 }
9315
9316 /* Fold a call to builtin frexp, we can assume the base is 2.  */
9317
9318 static tree
9319 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9320 {
9321   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9322     return NULL_TREE;
9323
9324   STRIP_NOPS (arg0);
9325
9326   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9327     return NULL_TREE;
9328
9329   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9330
9331   /* Proceed if a valid pointer type was passed in.  */
9332   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9333     {
9334       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9335       tree frac, exp;
9336
9337       switch (value->cl)
9338       {
9339       case rvc_zero:
9340         /* For +-0, return (*exp = 0, +-0).  */
9341         exp = integer_zero_node;
9342         frac = arg0;
9343         break;
9344       case rvc_nan:
9345       case rvc_inf:
9346         /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
9347         return omit_one_operand_loc (loc, rettype, arg0, arg1);
9348       case rvc_normal:
9349         {
9350           /* Since the frexp function always expects base 2, and in
9351              GCC normalized significands are already in the range
9352              [0.5, 1.0), we have exactly what frexp wants.  */
9353           REAL_VALUE_TYPE frac_rvt = *value;
9354           SET_REAL_EXP (&frac_rvt, 0);
9355           frac = build_real (rettype, frac_rvt);
9356           exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9357         }
9358         break;
9359       default:
9360         gcc_unreachable ();
9361       }
9362
9363       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9364       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9365       TREE_SIDE_EFFECTS (arg1) = 1;
9366       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9367     }
9368
9369   return NULL_TREE;
9370 }
9371
9372 /* Fold a call to builtin ldexp or scalbn/scalbln.  If LDEXP is true
9373    then we can assume the base is two.  If it's false, then we have to
9374    check the mode of the TYPE parameter in certain cases.  */
9375
9376 static tree
9377 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9378                             tree type, bool ldexp)
9379 {
9380   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9381     {
9382       STRIP_NOPS (arg0);
9383       STRIP_NOPS (arg1);
9384
9385       /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0.  */
9386       if (real_zerop (arg0) || integer_zerop (arg1)
9387           || (TREE_CODE (arg0) == REAL_CST
9388               && !real_isfinite (&TREE_REAL_CST (arg0))))
9389         return omit_one_operand_loc (loc, type, arg0, arg1);
9390
9391       /* If both arguments are constant, then try to evaluate it.  */
9392       if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9393           && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9394           && host_integerp (arg1, 0))
9395         {
9396           /* Bound the maximum adjustment to twice the range of the
9397              mode's valid exponents.  Use abs to ensure the range is
9398              positive as a sanity check.  */
9399           const long max_exp_adj = 2 *
9400             labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9401                  - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9402
9403           /* Get the user-requested adjustment.  */
9404           const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9405
9406           /* The requested adjustment must be inside this range.  This
9407              is a preliminary cap to avoid things like overflow, we
9408              may still fail to compute the result for other reasons.  */
9409           if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9410             {
9411               REAL_VALUE_TYPE initial_result;
9412
9413               real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9414
9415               /* Ensure we didn't overflow.  */
9416               if (! real_isinf (&initial_result))
9417                 {
9418                   const REAL_VALUE_TYPE trunc_result
9419                     = real_value_truncate (TYPE_MODE (type), initial_result);
9420
9421                   /* Only proceed if the target mode can hold the
9422                      resulting value.  */
9423                   if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9424                     return build_real (type, trunc_result);
9425                 }
9426             }
9427         }
9428     }
9429
9430   return NULL_TREE;
9431 }
9432
9433 /* Fold a call to builtin modf.  */
9434
9435 static tree
9436 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9437 {
9438   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9439     return NULL_TREE;
9440
9441   STRIP_NOPS (arg0);
9442
9443   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9444     return NULL_TREE;
9445
9446   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9447
9448   /* Proceed if a valid pointer type was passed in.  */
9449   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9450     {
9451       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9452       REAL_VALUE_TYPE trunc, frac;
9453
9454       switch (value->cl)
9455       {
9456       case rvc_nan:
9457       case rvc_zero:
9458         /* For +-NaN or +-0, return (*arg1 = arg0, arg0).  */
9459         trunc = frac = *value;
9460         break;
9461       case rvc_inf:
9462         /* For +-Inf, return (*arg1 = arg0, +-0).  */
9463         frac = dconst0;
9464         frac.sign = value->sign;
9465         trunc = *value;
9466         break;
9467       case rvc_normal:
9468         /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)).  */
9469         real_trunc (&trunc, VOIDmode, value);
9470         real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9471         /* If the original number was negative and already
9472            integral, then the fractional part is -0.0.  */
9473         if (value->sign && frac.cl == rvc_zero)
9474           frac.sign = value->sign;
9475         break;
9476       }
9477
9478       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9479       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9480                           build_real (rettype, trunc));
9481       TREE_SIDE_EFFECTS (arg1) = 1;
9482       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9483                           build_real (rettype, frac));
9484     }
9485
9486   return NULL_TREE;
9487 }
9488
9489 /* Given a location LOC, an interclass builtin function decl FNDECL
9490    and its single argument ARG, return an folded expression computing
9491    the same, or NULL_TREE if we either couldn't or didn't want to fold
9492    (the latter happen if there's an RTL instruction available).  */
9493
9494 static tree
9495 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9496 {
9497   enum machine_mode mode;
9498
9499   if (!validate_arg (arg, REAL_TYPE))
9500     return NULL_TREE;
9501
9502   if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9503     return NULL_TREE;
9504
9505   mode = TYPE_MODE (TREE_TYPE (arg));
9506
9507   /* If there is no optab, try generic code.  */
9508   switch (DECL_FUNCTION_CODE (fndecl))
9509     {
9510       tree result;
9511
9512     CASE_FLT_FN (BUILT_IN_ISINF):
9513       {
9514         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
9515         tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
9516         tree const type = TREE_TYPE (arg);
9517         REAL_VALUE_TYPE r;
9518         char buf[128];
9519
9520         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9521         real_from_string (&r, buf);
9522         result = build_call_expr (isgr_fn, 2,
9523                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9524                                   build_real (type, r));
9525         return result;
9526       }
9527     CASE_FLT_FN (BUILT_IN_FINITE):
9528     case BUILT_IN_ISFINITE:
9529       {
9530         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
9531         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9532         tree const type = TREE_TYPE (arg);
9533         REAL_VALUE_TYPE r;
9534         char buf[128];
9535
9536         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9537         real_from_string (&r, buf);
9538         result = build_call_expr (isle_fn, 2,
9539                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9540                                   build_real (type, r));
9541         /*result = fold_build2_loc (loc, UNGT_EXPR,
9542                                   TREE_TYPE (TREE_TYPE (fndecl)),
9543                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9544                                   build_real (type, r));
9545         result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9546                                   TREE_TYPE (TREE_TYPE (fndecl)),
9547                                   result);*/
9548         return result;
9549       }
9550     case BUILT_IN_ISNORMAL:
9551       {
9552         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9553            islessequal(fabs(x),DBL_MAX).  */
9554         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9555         tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
9556         tree const type = TREE_TYPE (arg);
9557         REAL_VALUE_TYPE rmax, rmin;
9558         char buf[128];
9559
9560         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9561         real_from_string (&rmax, buf);
9562         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9563         real_from_string (&rmin, buf);
9564         arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9565         result = build_call_expr (isle_fn, 2, arg,
9566                                   build_real (type, rmax));
9567         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
9568                               build_call_expr (isge_fn, 2, arg,
9569                                                build_real (type, rmin)));
9570         return result;
9571       }
9572     default:
9573       break;
9574     }
9575
9576   return NULL_TREE;
9577 }
9578
9579 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9580    ARG is the argument for the call.  */
9581
9582 static tree
9583 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
9584 {
9585   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9586   REAL_VALUE_TYPE r;
9587
9588   if (!validate_arg (arg, REAL_TYPE))
9589     return NULL_TREE;
9590
9591   switch (builtin_index)
9592     {
9593     case BUILT_IN_ISINF:
9594       if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9595         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9596
9597       if (TREE_CODE (arg) == REAL_CST)
9598         {
9599           r = TREE_REAL_CST (arg);
9600           if (real_isinf (&r))
9601             return real_compare (GT_EXPR, &r, &dconst0)
9602                    ? integer_one_node : integer_minus_one_node;
9603           else
9604             return integer_zero_node;
9605         }
9606
9607       return NULL_TREE;
9608
9609     case BUILT_IN_ISINF_SIGN:
9610       {
9611         /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9612         /* In a boolean context, GCC will fold the inner COND_EXPR to
9613            1.  So e.g. "if (isinf_sign(x))" would be folded to just
9614            "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9615         tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
9616         tree isinf_fn = built_in_decls[BUILT_IN_ISINF];
9617         tree tmp = NULL_TREE;
9618
9619         arg = builtin_save_expr (arg);
9620
9621         if (signbit_fn && isinf_fn)
9622           {
9623             tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
9624             tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
9625
9626             signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9627                                         signbit_call, integer_zero_node);
9628             isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9629                                       isinf_call, integer_zero_node);
9630
9631             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
9632                                integer_minus_one_node, integer_one_node);
9633             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9634                                isinf_call, tmp,
9635                                integer_zero_node);
9636           }
9637
9638         return tmp;
9639       }
9640
9641     case BUILT_IN_ISFINITE:
9642       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
9643           && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9644         return omit_one_operand_loc (loc, type, integer_one_node, arg);
9645
9646       if (TREE_CODE (arg) == REAL_CST)
9647         {
9648           r = TREE_REAL_CST (arg);
9649           return real_isfinite (&r) ? integer_one_node : integer_zero_node;
9650         }
9651
9652       return NULL_TREE;
9653
9654     case BUILT_IN_ISNAN:
9655       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
9656         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9657
9658       if (TREE_CODE (arg) == REAL_CST)
9659         {
9660           r = TREE_REAL_CST (arg);
9661           return real_isnan (&r) ? integer_one_node : integer_zero_node;
9662         }
9663
9664       arg = builtin_save_expr (arg);
9665       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
9666
9667     default:
9668       gcc_unreachable ();
9669     }
9670 }
9671
9672 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9673    This builtin will generate code to return the appropriate floating
9674    point classification depending on the value of the floating point
9675    number passed in.  The possible return values must be supplied as
9676    int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9677    FP_NORMAL, FP_SUBNORMAL and FP_ZERO.  The ellipses is for exactly
9678    one floating point argument which is "type generic".  */
9679
9680 static tree
9681 fold_builtin_fpclassify (location_t loc, tree exp)
9682 {
9683   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
9684     arg, type, res, tmp;
9685   enum machine_mode mode;
9686   REAL_VALUE_TYPE r;
9687   char buf[128];
9688
9689   /* Verify the required arguments in the original call.  */
9690   if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
9691                          INTEGER_TYPE, INTEGER_TYPE,
9692                          INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
9693     return NULL_TREE;
9694
9695   fp_nan = CALL_EXPR_ARG (exp, 0);
9696   fp_infinite = CALL_EXPR_ARG (exp, 1);
9697   fp_normal = CALL_EXPR_ARG (exp, 2);
9698   fp_subnormal = CALL_EXPR_ARG (exp, 3);
9699   fp_zero = CALL_EXPR_ARG (exp, 4);
9700   arg = CALL_EXPR_ARG (exp, 5);
9701   type = TREE_TYPE (arg);
9702   mode = TYPE_MODE (type);
9703   arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9704
9705   /* fpclassify(x) ->
9706        isnan(x) ? FP_NAN :
9707          (fabs(x) == Inf ? FP_INFINITE :
9708            (fabs(x) >= DBL_MIN ? FP_NORMAL :
9709              (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
9710
9711   tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9712                      build_real (type, dconst0));
9713   res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9714                      tmp, fp_zero, fp_subnormal);
9715
9716   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9717   real_from_string (&r, buf);
9718   tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
9719                      arg, build_real (type, r));
9720   res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
9721
9722   if (HONOR_INFINITIES (mode))
9723     {
9724       real_inf (&r);
9725       tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9726                          build_real (type, r));
9727       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
9728                          fp_infinite, res);
9729     }
9730
9731   if (HONOR_NANS (mode))
9732     {
9733       tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
9734       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
9735     }
9736
9737   return res;
9738 }
9739
9740 /* Fold a call to an unordered comparison function such as
9741    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
9742    being called and ARG0 and ARG1 are the arguments for the call.
9743    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9744    the opposite of the desired result.  UNORDERED_CODE is used
9745    for modes that can hold NaNs and ORDERED_CODE is used for
9746    the rest.  */
9747
9748 static tree
9749 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
9750                             enum tree_code unordered_code,
9751                             enum tree_code ordered_code)
9752 {
9753   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9754   enum tree_code code;
9755   tree type0, type1;
9756   enum tree_code code0, code1;
9757   tree cmp_type = NULL_TREE;
9758
9759   type0 = TREE_TYPE (arg0);
9760   type1 = TREE_TYPE (arg1);
9761
9762   code0 = TREE_CODE (type0);
9763   code1 = TREE_CODE (type1);
9764
9765   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
9766     /* Choose the wider of two real types.  */
9767     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
9768       ? type0 : type1;
9769   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
9770     cmp_type = type0;
9771   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
9772     cmp_type = type1;
9773
9774   arg0 = fold_convert_loc (loc, cmp_type, arg0);
9775   arg1 = fold_convert_loc (loc, cmp_type, arg1);
9776
9777   if (unordered_code == UNORDERED_EXPR)
9778     {
9779       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9780         return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
9781       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
9782     }
9783
9784   code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
9785                                                    : ordered_code;
9786   return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
9787                       fold_build2_loc (loc, code, type, arg0, arg1));
9788 }
9789
9790 /* Fold a call to built-in function FNDECL with 0 arguments.
9791    IGNORE is true if the result of the function call is ignored.  This
9792    function returns NULL_TREE if no simplification was possible.  */
9793
9794 static tree
9795 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
9796 {
9797   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9798   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9799   switch (fcode)
9800     {
9801     CASE_FLT_FN (BUILT_IN_INF):
9802     case BUILT_IN_INFD32:
9803     case BUILT_IN_INFD64:
9804     case BUILT_IN_INFD128:
9805       return fold_builtin_inf (loc, type, true);
9806
9807     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
9808       return fold_builtin_inf (loc, type, false);
9809
9810     case BUILT_IN_CLASSIFY_TYPE:
9811       return fold_builtin_classify_type (NULL_TREE);
9812
9813     default:
9814       break;
9815     }
9816   return NULL_TREE;
9817 }
9818
9819 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9820    IGNORE is true if the result of the function call is ignored.  This
9821    function returns NULL_TREE if no simplification was possible.  */
9822
9823 static tree
9824 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
9825 {
9826   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9827   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9828   switch (fcode)
9829     {
9830     case BUILT_IN_CONSTANT_P:
9831       {
9832         tree val = fold_builtin_constant_p (arg0);
9833
9834         /* Gimplification will pull the CALL_EXPR for the builtin out of
9835            an if condition.  When not optimizing, we'll not CSE it back.
9836            To avoid link error types of regressions, return false now.  */
9837         if (!val && !optimize)
9838           val = integer_zero_node;
9839
9840         return val;
9841       }
9842
9843     case BUILT_IN_CLASSIFY_TYPE:
9844       return fold_builtin_classify_type (arg0);
9845
9846     case BUILT_IN_STRLEN:
9847       return fold_builtin_strlen (loc, type, arg0);
9848
9849     CASE_FLT_FN (BUILT_IN_FABS):
9850       return fold_builtin_fabs (loc, arg0, type);
9851
9852     case BUILT_IN_ABS:
9853     case BUILT_IN_LABS:
9854     case BUILT_IN_LLABS:
9855     case BUILT_IN_IMAXABS:
9856       return fold_builtin_abs (loc, arg0, type);
9857
9858     CASE_FLT_FN (BUILT_IN_CONJ):
9859       if (validate_arg (arg0, COMPLEX_TYPE)
9860         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9861         return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
9862     break;
9863
9864     CASE_FLT_FN (BUILT_IN_CREAL):
9865       if (validate_arg (arg0, COMPLEX_TYPE)
9866         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9867         return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
9868     break;
9869
9870     CASE_FLT_FN (BUILT_IN_CIMAG):
9871       if (validate_arg (arg0, COMPLEX_TYPE)
9872           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9873         return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
9874     break;
9875
9876     CASE_FLT_FN (BUILT_IN_CCOS):
9877       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
9878
9879     CASE_FLT_FN (BUILT_IN_CCOSH):
9880       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
9881
9882     CASE_FLT_FN (BUILT_IN_CPROJ):
9883       return fold_builtin_cproj(loc, arg0, type);
9884
9885     CASE_FLT_FN (BUILT_IN_CSIN):
9886       if (validate_arg (arg0, COMPLEX_TYPE)
9887           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9888         return do_mpc_arg1 (arg0, type, mpc_sin);
9889     break;
9890
9891     CASE_FLT_FN (BUILT_IN_CSINH):
9892       if (validate_arg (arg0, COMPLEX_TYPE)
9893           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9894         return do_mpc_arg1 (arg0, type, mpc_sinh);
9895     break;
9896
9897     CASE_FLT_FN (BUILT_IN_CTAN):
9898       if (validate_arg (arg0, COMPLEX_TYPE)
9899           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9900         return do_mpc_arg1 (arg0, type, mpc_tan);
9901     break;
9902
9903     CASE_FLT_FN (BUILT_IN_CTANH):
9904       if (validate_arg (arg0, COMPLEX_TYPE)
9905           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9906         return do_mpc_arg1 (arg0, type, mpc_tanh);
9907     break;
9908
9909     CASE_FLT_FN (BUILT_IN_CLOG):
9910       if (validate_arg (arg0, COMPLEX_TYPE)
9911           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9912         return do_mpc_arg1 (arg0, type, mpc_log);
9913     break;
9914
9915     CASE_FLT_FN (BUILT_IN_CSQRT):
9916       if (validate_arg (arg0, COMPLEX_TYPE)
9917           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9918         return do_mpc_arg1 (arg0, type, mpc_sqrt);
9919     break;
9920
9921     CASE_FLT_FN (BUILT_IN_CASIN):
9922       if (validate_arg (arg0, COMPLEX_TYPE)
9923           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9924         return do_mpc_arg1 (arg0, type, mpc_asin);
9925     break;
9926
9927     CASE_FLT_FN (BUILT_IN_CACOS):
9928       if (validate_arg (arg0, COMPLEX_TYPE)
9929           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9930         return do_mpc_arg1 (arg0, type, mpc_acos);
9931     break;
9932
9933     CASE_FLT_FN (BUILT_IN_CATAN):
9934       if (validate_arg (arg0, COMPLEX_TYPE)
9935           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9936         return do_mpc_arg1 (arg0, type, mpc_atan);
9937     break;
9938
9939     CASE_FLT_FN (BUILT_IN_CASINH):
9940       if (validate_arg (arg0, COMPLEX_TYPE)
9941           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9942         return do_mpc_arg1 (arg0, type, mpc_asinh);
9943     break;
9944
9945     CASE_FLT_FN (BUILT_IN_CACOSH):
9946       if (validate_arg (arg0, COMPLEX_TYPE)
9947           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9948         return do_mpc_arg1 (arg0, type, mpc_acosh);
9949     break;
9950
9951     CASE_FLT_FN (BUILT_IN_CATANH):
9952       if (validate_arg (arg0, COMPLEX_TYPE)
9953           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9954         return do_mpc_arg1 (arg0, type, mpc_atanh);
9955     break;
9956
9957     CASE_FLT_FN (BUILT_IN_CABS):
9958       return fold_builtin_cabs (loc, arg0, type, fndecl);
9959
9960     CASE_FLT_FN (BUILT_IN_CARG):
9961       return fold_builtin_carg (loc, arg0, type);
9962
9963     CASE_FLT_FN (BUILT_IN_SQRT):
9964       return fold_builtin_sqrt (loc, arg0, type);
9965
9966     CASE_FLT_FN (BUILT_IN_CBRT):
9967       return fold_builtin_cbrt (loc, arg0, type);
9968
9969     CASE_FLT_FN (BUILT_IN_ASIN):
9970       if (validate_arg (arg0, REAL_TYPE))
9971         return do_mpfr_arg1 (arg0, type, mpfr_asin,
9972                              &dconstm1, &dconst1, true);
9973     break;
9974
9975     CASE_FLT_FN (BUILT_IN_ACOS):
9976       if (validate_arg (arg0, REAL_TYPE))
9977         return do_mpfr_arg1 (arg0, type, mpfr_acos,
9978                              &dconstm1, &dconst1, true);
9979     break;
9980
9981     CASE_FLT_FN (BUILT_IN_ATAN):
9982       if (validate_arg (arg0, REAL_TYPE))
9983         return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
9984     break;
9985
9986     CASE_FLT_FN (BUILT_IN_ASINH):
9987       if (validate_arg (arg0, REAL_TYPE))
9988         return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
9989     break;
9990
9991     CASE_FLT_FN (BUILT_IN_ACOSH):
9992       if (validate_arg (arg0, REAL_TYPE))
9993         return do_mpfr_arg1 (arg0, type, mpfr_acosh,
9994                              &dconst1, NULL, true);
9995     break;
9996
9997     CASE_FLT_FN (BUILT_IN_ATANH):
9998       if (validate_arg (arg0, REAL_TYPE))
9999         return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10000                              &dconstm1, &dconst1, false);
10001     break;
10002
10003     CASE_FLT_FN (BUILT_IN_SIN):
10004       if (validate_arg (arg0, REAL_TYPE))
10005         return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10006     break;
10007
10008     CASE_FLT_FN (BUILT_IN_COS):
10009       return fold_builtin_cos (loc, arg0, type, fndecl);
10010
10011     CASE_FLT_FN (BUILT_IN_TAN):
10012       return fold_builtin_tan (arg0, type);
10013
10014     CASE_FLT_FN (BUILT_IN_CEXP):
10015       return fold_builtin_cexp (loc, arg0, type);
10016
10017     CASE_FLT_FN (BUILT_IN_CEXPI):
10018       if (validate_arg (arg0, REAL_TYPE))
10019         return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10020     break;
10021
10022     CASE_FLT_FN (BUILT_IN_SINH):
10023       if (validate_arg (arg0, REAL_TYPE))
10024         return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10025     break;
10026
10027     CASE_FLT_FN (BUILT_IN_COSH):
10028       return fold_builtin_cosh (loc, arg0, type, fndecl);
10029
10030     CASE_FLT_FN (BUILT_IN_TANH):
10031       if (validate_arg (arg0, REAL_TYPE))
10032         return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10033     break;
10034
10035     CASE_FLT_FN (BUILT_IN_ERF):
10036       if (validate_arg (arg0, REAL_TYPE))
10037         return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10038     break;
10039
10040     CASE_FLT_FN (BUILT_IN_ERFC):
10041       if (validate_arg (arg0, REAL_TYPE))
10042         return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10043     break;
10044
10045     CASE_FLT_FN (BUILT_IN_TGAMMA):
10046       if (validate_arg (arg0, REAL_TYPE))
10047         return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10048     break;
10049
10050     CASE_FLT_FN (BUILT_IN_EXP):
10051       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10052
10053     CASE_FLT_FN (BUILT_IN_EXP2):
10054       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10055
10056     CASE_FLT_FN (BUILT_IN_EXP10):
10057     CASE_FLT_FN (BUILT_IN_POW10):
10058       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10059
10060     CASE_FLT_FN (BUILT_IN_EXPM1):
10061       if (validate_arg (arg0, REAL_TYPE))
10062         return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10063     break;
10064
10065     CASE_FLT_FN (BUILT_IN_LOG):
10066     return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10067
10068     CASE_FLT_FN (BUILT_IN_LOG2):
10069       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10070
10071     CASE_FLT_FN (BUILT_IN_LOG10):
10072       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10073
10074     CASE_FLT_FN (BUILT_IN_LOG1P):
10075       if (validate_arg (arg0, REAL_TYPE))
10076         return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10077                              &dconstm1, NULL, false);
10078     break;
10079
10080     CASE_FLT_FN (BUILT_IN_J0):
10081       if (validate_arg (arg0, REAL_TYPE))
10082         return do_mpfr_arg1 (arg0, type, mpfr_j0,
10083                              NULL, NULL, 0);
10084     break;
10085
10086     CASE_FLT_FN (BUILT_IN_J1):
10087       if (validate_arg (arg0, REAL_TYPE))
10088         return do_mpfr_arg1 (arg0, type, mpfr_j1,
10089                              NULL, NULL, 0);
10090     break;
10091
10092     CASE_FLT_FN (BUILT_IN_Y0):
10093       if (validate_arg (arg0, REAL_TYPE))
10094         return do_mpfr_arg1 (arg0, type, mpfr_y0,
10095                              &dconst0, NULL, false);
10096     break;
10097
10098     CASE_FLT_FN (BUILT_IN_Y1):
10099       if (validate_arg (arg0, REAL_TYPE))
10100         return do_mpfr_arg1 (arg0, type, mpfr_y1,
10101                              &dconst0, NULL, false);
10102     break;
10103
10104     CASE_FLT_FN (BUILT_IN_NAN):
10105     case BUILT_IN_NAND32:
10106     case BUILT_IN_NAND64:
10107     case BUILT_IN_NAND128:
10108       return fold_builtin_nan (arg0, type, true);
10109
10110     CASE_FLT_FN (BUILT_IN_NANS):
10111       return fold_builtin_nan (arg0, type, false);
10112
10113     CASE_FLT_FN (BUILT_IN_FLOOR):
10114       return fold_builtin_floor (loc, fndecl, arg0);
10115
10116     CASE_FLT_FN (BUILT_IN_CEIL):
10117       return fold_builtin_ceil (loc, fndecl, arg0);
10118
10119     CASE_FLT_FN (BUILT_IN_TRUNC):
10120       return fold_builtin_trunc (loc, fndecl, arg0);
10121
10122     CASE_FLT_FN (BUILT_IN_ROUND):
10123       return fold_builtin_round (loc, fndecl, arg0);
10124
10125     CASE_FLT_FN (BUILT_IN_NEARBYINT):
10126     CASE_FLT_FN (BUILT_IN_RINT):
10127       return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10128
10129     CASE_FLT_FN (BUILT_IN_LCEIL):
10130     CASE_FLT_FN (BUILT_IN_LLCEIL):
10131     CASE_FLT_FN (BUILT_IN_LFLOOR):
10132     CASE_FLT_FN (BUILT_IN_LLFLOOR):
10133     CASE_FLT_FN (BUILT_IN_LROUND):
10134     CASE_FLT_FN (BUILT_IN_LLROUND):
10135       return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10136
10137     CASE_FLT_FN (BUILT_IN_LRINT):
10138     CASE_FLT_FN (BUILT_IN_LLRINT):
10139       return fold_fixed_mathfn (loc, fndecl, arg0);
10140
10141     case BUILT_IN_BSWAP32:
10142     case BUILT_IN_BSWAP64:
10143       return fold_builtin_bswap (fndecl, arg0);
10144
10145     CASE_INT_FN (BUILT_IN_FFS):
10146     CASE_INT_FN (BUILT_IN_CLZ):
10147     CASE_INT_FN (BUILT_IN_CTZ):
10148     CASE_INT_FN (BUILT_IN_POPCOUNT):
10149     CASE_INT_FN (BUILT_IN_PARITY):
10150       return fold_builtin_bitop (fndecl, arg0);
10151
10152     CASE_FLT_FN (BUILT_IN_SIGNBIT):
10153       return fold_builtin_signbit (loc, arg0, type);
10154
10155     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10156       return fold_builtin_significand (loc, arg0, type);
10157
10158     CASE_FLT_FN (BUILT_IN_ILOGB):
10159     CASE_FLT_FN (BUILT_IN_LOGB):
10160       return fold_builtin_logb (loc, arg0, type);
10161
10162     case BUILT_IN_ISASCII:
10163       return fold_builtin_isascii (loc, arg0);
10164
10165     case BUILT_IN_TOASCII:
10166       return fold_builtin_toascii (loc, arg0);
10167
10168     case BUILT_IN_ISDIGIT:
10169       return fold_builtin_isdigit (loc, arg0);
10170
10171     CASE_FLT_FN (BUILT_IN_FINITE):
10172     case BUILT_IN_FINITED32:
10173     case BUILT_IN_FINITED64:
10174     case BUILT_IN_FINITED128:
10175     case BUILT_IN_ISFINITE:
10176       {
10177         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10178         if (ret)
10179           return ret;
10180         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10181       }
10182
10183     CASE_FLT_FN (BUILT_IN_ISINF):
10184     case BUILT_IN_ISINFD32:
10185     case BUILT_IN_ISINFD64:
10186     case BUILT_IN_ISINFD128:
10187       {
10188         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10189         if (ret)
10190           return ret;
10191         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10192       }
10193
10194     case BUILT_IN_ISNORMAL:
10195       return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10196
10197     case BUILT_IN_ISINF_SIGN:
10198       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10199
10200     CASE_FLT_FN (BUILT_IN_ISNAN):
10201     case BUILT_IN_ISNAND32:
10202     case BUILT_IN_ISNAND64:
10203     case BUILT_IN_ISNAND128:
10204       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10205
10206     case BUILT_IN_PRINTF:
10207     case BUILT_IN_PRINTF_UNLOCKED:
10208     case BUILT_IN_VPRINTF:
10209       return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10210
10211     case BUILT_IN_FREE:
10212       if (integer_zerop (arg0))
10213         return build_empty_stmt (loc);
10214       break;
10215
10216     default:
10217       break;
10218     }
10219
10220   return NULL_TREE;
10221
10222 }
10223
10224 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10225    IGNORE is true if the result of the function call is ignored.  This
10226    function returns NULL_TREE if no simplification was possible.  */
10227
10228 static tree
10229 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10230 {
10231   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10232   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10233
10234   switch (fcode)
10235     {
10236     CASE_FLT_FN (BUILT_IN_JN):
10237       if (validate_arg (arg0, INTEGER_TYPE)
10238           && validate_arg (arg1, REAL_TYPE))
10239         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10240     break;
10241
10242     CASE_FLT_FN (BUILT_IN_YN):
10243       if (validate_arg (arg0, INTEGER_TYPE)
10244           && validate_arg (arg1, REAL_TYPE))
10245         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10246                                  &dconst0, false);
10247     break;
10248
10249     CASE_FLT_FN (BUILT_IN_DREM):
10250     CASE_FLT_FN (BUILT_IN_REMAINDER):
10251       if (validate_arg (arg0, REAL_TYPE)
10252           && validate_arg(arg1, REAL_TYPE))
10253         return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10254     break;
10255
10256     CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10257     CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10258       if (validate_arg (arg0, REAL_TYPE)
10259           && validate_arg(arg1, POINTER_TYPE))
10260         return do_mpfr_lgamma_r (arg0, arg1, type);
10261     break;
10262
10263     CASE_FLT_FN (BUILT_IN_ATAN2):
10264       if (validate_arg (arg0, REAL_TYPE)
10265           && validate_arg(arg1, REAL_TYPE))
10266         return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10267     break;
10268
10269     CASE_FLT_FN (BUILT_IN_FDIM):
10270       if (validate_arg (arg0, REAL_TYPE)
10271           && validate_arg(arg1, REAL_TYPE))
10272         return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10273     break;
10274
10275     CASE_FLT_FN (BUILT_IN_HYPOT):
10276       return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10277
10278     CASE_FLT_FN (BUILT_IN_CPOW):
10279       if (validate_arg (arg0, COMPLEX_TYPE)
10280           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10281           && validate_arg (arg1, COMPLEX_TYPE)
10282           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10283         return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10284     break;
10285
10286     CASE_FLT_FN (BUILT_IN_LDEXP):
10287       return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10288     CASE_FLT_FN (BUILT_IN_SCALBN):
10289     CASE_FLT_FN (BUILT_IN_SCALBLN):
10290       return fold_builtin_load_exponent (loc, arg0, arg1,
10291                                          type, /*ldexp=*/false);
10292
10293     CASE_FLT_FN (BUILT_IN_FREXP):
10294       return fold_builtin_frexp (loc, arg0, arg1, type);
10295
10296     CASE_FLT_FN (BUILT_IN_MODF):
10297       return fold_builtin_modf (loc, arg0, arg1, type);
10298
10299     case BUILT_IN_BZERO:
10300       return fold_builtin_bzero (loc, arg0, arg1, ignore);
10301
10302     case BUILT_IN_FPUTS:
10303       return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10304
10305     case BUILT_IN_FPUTS_UNLOCKED:
10306       return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10307
10308     case BUILT_IN_STRSTR:
10309       return fold_builtin_strstr (loc, arg0, arg1, type);
10310
10311     case BUILT_IN_STRCAT:
10312       return fold_builtin_strcat (loc, arg0, arg1);
10313
10314     case BUILT_IN_STRSPN:
10315       return fold_builtin_strspn (loc, arg0, arg1);
10316
10317     case BUILT_IN_STRCSPN:
10318       return fold_builtin_strcspn (loc, arg0, arg1);
10319
10320     case BUILT_IN_STRCHR:
10321     case BUILT_IN_INDEX:
10322       return fold_builtin_strchr (loc, arg0, arg1, type);
10323
10324     case BUILT_IN_STRRCHR:
10325     case BUILT_IN_RINDEX:
10326       return fold_builtin_strrchr (loc, arg0, arg1, type);
10327
10328     case BUILT_IN_STRCPY:
10329       return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10330
10331     case BUILT_IN_STPCPY:
10332       if (ignore)
10333         {
10334           tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
10335           if (!fn)
10336             break;
10337
10338           return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10339         }
10340       else
10341         return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10342       break;
10343
10344     case BUILT_IN_STRCMP:
10345       return fold_builtin_strcmp (loc, arg0, arg1);
10346
10347     case BUILT_IN_STRPBRK:
10348       return fold_builtin_strpbrk (loc, arg0, arg1, type);
10349
10350     case BUILT_IN_EXPECT:
10351       return fold_builtin_expect (loc, arg0, arg1);
10352
10353     CASE_FLT_FN (BUILT_IN_POW):
10354       return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10355
10356     CASE_FLT_FN (BUILT_IN_POWI):
10357       return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10358
10359     CASE_FLT_FN (BUILT_IN_COPYSIGN):
10360       return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10361
10362     CASE_FLT_FN (BUILT_IN_FMIN):
10363       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10364
10365     CASE_FLT_FN (BUILT_IN_FMAX):
10366       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10367
10368     case BUILT_IN_ISGREATER:
10369       return fold_builtin_unordered_cmp (loc, fndecl,
10370                                          arg0, arg1, UNLE_EXPR, LE_EXPR);
10371     case BUILT_IN_ISGREATEREQUAL:
10372       return fold_builtin_unordered_cmp (loc, fndecl,
10373                                          arg0, arg1, UNLT_EXPR, LT_EXPR);
10374     case BUILT_IN_ISLESS:
10375       return fold_builtin_unordered_cmp (loc, fndecl,
10376                                          arg0, arg1, UNGE_EXPR, GE_EXPR);
10377     case BUILT_IN_ISLESSEQUAL:
10378       return fold_builtin_unordered_cmp (loc, fndecl,
10379                                          arg0, arg1, UNGT_EXPR, GT_EXPR);
10380     case BUILT_IN_ISLESSGREATER:
10381       return fold_builtin_unordered_cmp (loc, fndecl,
10382                                          arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10383     case BUILT_IN_ISUNORDERED:
10384       return fold_builtin_unordered_cmp (loc, fndecl,
10385                                          arg0, arg1, UNORDERED_EXPR,
10386                                          NOP_EXPR);
10387
10388       /* We do the folding for va_start in the expander.  */
10389     case BUILT_IN_VA_START:
10390       break;
10391
10392     case BUILT_IN_SPRINTF:
10393       return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10394
10395     case BUILT_IN_OBJECT_SIZE:
10396       return fold_builtin_object_size (arg0, arg1);
10397
10398     case BUILT_IN_PRINTF:
10399     case BUILT_IN_PRINTF_UNLOCKED:
10400     case BUILT_IN_VPRINTF:
10401       return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10402
10403     case BUILT_IN_PRINTF_CHK:
10404     case BUILT_IN_VPRINTF_CHK:
10405       if (!validate_arg (arg0, INTEGER_TYPE)
10406           || TREE_SIDE_EFFECTS (arg0))
10407         return NULL_TREE;
10408       else
10409         return fold_builtin_printf (loc, fndecl,
10410                                     arg1, NULL_TREE, ignore, fcode);
10411     break;
10412
10413     case BUILT_IN_FPRINTF:
10414     case BUILT_IN_FPRINTF_UNLOCKED:
10415     case BUILT_IN_VFPRINTF:
10416       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10417                                    ignore, fcode);
10418
10419     default:
10420       break;
10421     }
10422   return NULL_TREE;
10423 }
10424
10425 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10426    and ARG2.  IGNORE is true if the result of the function call is ignored.
10427    This function returns NULL_TREE if no simplification was possible.  */
10428
10429 static tree
10430 fold_builtin_3 (location_t loc, tree fndecl,
10431                 tree arg0, tree arg1, tree arg2, bool ignore)
10432 {
10433   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10434   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10435   switch (fcode)
10436     {
10437
10438     CASE_FLT_FN (BUILT_IN_SINCOS):
10439       return fold_builtin_sincos (loc, arg0, arg1, arg2);
10440
10441     CASE_FLT_FN (BUILT_IN_FMA):
10442       if (validate_arg (arg0, REAL_TYPE)
10443           && validate_arg(arg1, REAL_TYPE)
10444           && validate_arg(arg2, REAL_TYPE))
10445         return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
10446     break;
10447
10448     CASE_FLT_FN (BUILT_IN_REMQUO):
10449       if (validate_arg (arg0, REAL_TYPE)
10450           && validate_arg(arg1, REAL_TYPE)
10451           && validate_arg(arg2, POINTER_TYPE))
10452         return do_mpfr_remquo (arg0, arg1, arg2);
10453     break;
10454
10455     case BUILT_IN_MEMSET:
10456       return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10457
10458     case BUILT_IN_BCOPY:
10459       return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10460                                      void_type_node, true, /*endp=*/3);
10461
10462     case BUILT_IN_MEMCPY:
10463       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10464                                      type, ignore, /*endp=*/0);
10465
10466     case BUILT_IN_MEMPCPY:
10467       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10468                                      type, ignore, /*endp=*/1);
10469
10470     case BUILT_IN_MEMMOVE:
10471       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10472                                      type, ignore, /*endp=*/3);
10473
10474     case BUILT_IN_STRNCAT:
10475       return fold_builtin_strncat (loc, arg0, arg1, arg2);
10476
10477     case BUILT_IN_STRNCPY:
10478       return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10479
10480     case BUILT_IN_STRNCMP:
10481       return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10482
10483     case BUILT_IN_MEMCHR:
10484       return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10485
10486     case BUILT_IN_BCMP:
10487     case BUILT_IN_MEMCMP:
10488       return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10489
10490     case BUILT_IN_SPRINTF:
10491       return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10492
10493     case BUILT_IN_STRCPY_CHK:
10494     case BUILT_IN_STPCPY_CHK:
10495       return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10496                                       ignore, fcode);
10497
10498     case BUILT_IN_STRCAT_CHK:
10499       return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10500
10501     case BUILT_IN_PRINTF_CHK:
10502     case BUILT_IN_VPRINTF_CHK:
10503       if (!validate_arg (arg0, INTEGER_TYPE)
10504           || TREE_SIDE_EFFECTS (arg0))
10505         return NULL_TREE;
10506       else
10507         return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10508     break;
10509
10510     case BUILT_IN_FPRINTF:
10511     case BUILT_IN_FPRINTF_UNLOCKED:
10512     case BUILT_IN_VFPRINTF:
10513       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10514                                    ignore, fcode);
10515
10516     case BUILT_IN_FPRINTF_CHK:
10517     case BUILT_IN_VFPRINTF_CHK:
10518       if (!validate_arg (arg1, INTEGER_TYPE)
10519           || TREE_SIDE_EFFECTS (arg1))
10520         return NULL_TREE;
10521       else
10522         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10523                                      ignore, fcode);
10524
10525     default:
10526       break;
10527     }
10528   return NULL_TREE;
10529 }
10530
10531 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10532    ARG2, and ARG3.  IGNORE is true if the result of the function call is
10533    ignored.  This function returns NULL_TREE if no simplification was
10534    possible.  */
10535
10536 static tree
10537 fold_builtin_4 (location_t loc, tree fndecl,
10538                 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10539 {
10540   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10541
10542   switch (fcode)
10543     {
10544     case BUILT_IN_MEMCPY_CHK:
10545     case BUILT_IN_MEMPCPY_CHK:
10546     case BUILT_IN_MEMMOVE_CHK:
10547     case BUILT_IN_MEMSET_CHK:
10548       return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10549                                       NULL_TREE, ignore,
10550                                       DECL_FUNCTION_CODE (fndecl));
10551
10552     case BUILT_IN_STRNCPY_CHK:
10553       return fold_builtin_strncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE);
10554
10555     case BUILT_IN_STRNCAT_CHK:
10556       return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
10557
10558     case BUILT_IN_FPRINTF_CHK:
10559     case BUILT_IN_VFPRINTF_CHK:
10560       if (!validate_arg (arg1, INTEGER_TYPE)
10561           || TREE_SIDE_EFFECTS (arg1))
10562         return NULL_TREE;
10563       else
10564         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
10565                                      ignore, fcode);
10566     break;
10567
10568     default:
10569       break;
10570     }
10571   return NULL_TREE;
10572 }
10573
10574 /* Fold a call to built-in function FNDECL.  ARGS is an array of NARGS
10575     arguments, where NARGS <= 4.  IGNORE is true if the result of the
10576     function call is ignored.  This function returns NULL_TREE if no
10577     simplification was possible.  Note that this only folds builtins with
10578     fixed argument patterns.  Foldings that do varargs-to-varargs
10579     transformations, or that match calls with more than 4 arguments,
10580     need to be handled with fold_builtin_varargs instead.  */
10581
10582 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10583
10584 static tree
10585 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
10586 {
10587   tree ret = NULL_TREE;
10588
10589   switch (nargs)
10590     {
10591     case 0:
10592       ret = fold_builtin_0 (loc, fndecl, ignore);
10593       break;
10594     case 1:
10595       ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
10596       break;
10597     case 2:
10598       ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
10599       break;
10600     case 3:
10601       ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
10602       break;
10603     case 4:
10604       ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
10605                             ignore);
10606       break;
10607     default:
10608       break;
10609     }
10610   if (ret)
10611     {
10612       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10613       SET_EXPR_LOCATION (ret, loc);
10614       TREE_NO_WARNING (ret) = 1;
10615       return ret;
10616     }
10617   return NULL_TREE;
10618 }
10619
10620 /* Builtins with folding operations that operate on "..." arguments
10621    need special handling; we need to store the arguments in a convenient
10622    data structure before attempting any folding.  Fortunately there are
10623    only a few builtins that fall into this category.  FNDECL is the
10624    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10625    result of the function call is ignored.  */
10626
10627 static tree
10628 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
10629                       bool ignore ATTRIBUTE_UNUSED)
10630 {
10631   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10632   tree ret = NULL_TREE;
10633
10634   switch (fcode)
10635     {
10636     case BUILT_IN_SPRINTF_CHK:
10637     case BUILT_IN_VSPRINTF_CHK:
10638       ret = fold_builtin_sprintf_chk (loc, exp, fcode);
10639       break;
10640
10641     case BUILT_IN_SNPRINTF_CHK:
10642     case BUILT_IN_VSNPRINTF_CHK:
10643       ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
10644       break;
10645
10646     case BUILT_IN_FPCLASSIFY:
10647       ret = fold_builtin_fpclassify (loc, exp);
10648       break;
10649
10650     default:
10651       break;
10652     }
10653   if (ret)
10654     {
10655       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10656       SET_EXPR_LOCATION (ret, loc);
10657       TREE_NO_WARNING (ret) = 1;
10658       return ret;
10659     }
10660   return NULL_TREE;
10661 }
10662
10663 /* Return true if FNDECL shouldn't be folded right now.
10664    If a built-in function has an inline attribute always_inline
10665    wrapper, defer folding it after always_inline functions have
10666    been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10667    might not be performed.  */
10668
10669 static bool
10670 avoid_folding_inline_builtin (tree fndecl)
10671 {
10672   return (DECL_DECLARED_INLINE_P (fndecl)
10673           && DECL_DISREGARD_INLINE_LIMITS (fndecl)
10674           && cfun
10675           && !cfun->always_inline_functions_inlined
10676           && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
10677 }
10678
10679 /* A wrapper function for builtin folding that prevents warnings for
10680    "statement without effect" and the like, caused by removing the
10681    call node earlier than the warning is generated.  */
10682
10683 tree
10684 fold_call_expr (location_t loc, tree exp, bool ignore)
10685 {
10686   tree ret = NULL_TREE;
10687   tree fndecl = get_callee_fndecl (exp);
10688   if (fndecl
10689       && TREE_CODE (fndecl) == FUNCTION_DECL
10690       && DECL_BUILT_IN (fndecl)
10691       /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10692          yet.  Defer folding until we see all the arguments
10693          (after inlining).  */
10694       && !CALL_EXPR_VA_ARG_PACK (exp))
10695     {
10696       int nargs = call_expr_nargs (exp);
10697
10698       /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10699          instead last argument is __builtin_va_arg_pack ().  Defer folding
10700          even in that case, until arguments are finalized.  */
10701       if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
10702         {
10703           tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
10704           if (fndecl2
10705               && TREE_CODE (fndecl2) == FUNCTION_DECL
10706               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10707               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10708             return NULL_TREE;
10709         }
10710
10711       if (avoid_folding_inline_builtin (fndecl))
10712         return NULL_TREE;
10713
10714       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10715         return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
10716                                      CALL_EXPR_ARGP (exp), ignore);
10717       else
10718         {
10719           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
10720             {
10721               tree *args = CALL_EXPR_ARGP (exp);
10722               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
10723             }
10724           if (!ret)
10725             ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
10726           if (ret)
10727             return ret;
10728         }
10729     }
10730   return NULL_TREE;
10731 }
10732
10733 /* Conveniently construct a function call expression.  FNDECL names the
10734    function to be called and N arguments are passed in the array
10735    ARGARRAY.  */
10736
10737 tree
10738 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
10739 {
10740   tree fntype = TREE_TYPE (fndecl);
10741   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10742
10743   return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10744 }
10745
10746 /* Conveniently construct a function call expression.  FNDECL names the
10747    function to be called and the arguments are passed in the vector
10748    VEC.  */
10749
10750 tree
10751 build_call_expr_loc_vec (location_t loc, tree fndecl, VEC(tree,gc) *vec)
10752 {
10753   return build_call_expr_loc_array (loc, fndecl, VEC_length (tree, vec),
10754                                     VEC_address (tree, vec));
10755 }
10756
10757
10758 /* Conveniently construct a function call expression.  FNDECL names the
10759    function to be called, N is the number of arguments, and the "..."
10760    parameters are the argument expressions.  */
10761
10762 tree
10763 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10764 {
10765   va_list ap;
10766   tree *argarray = XALLOCAVEC (tree, n);
10767   int i;
10768
10769   va_start (ap, n);
10770   for (i = 0; i < n; i++)
10771     argarray[i] = va_arg (ap, tree);
10772   va_end (ap);
10773   return build_call_expr_loc_array (loc, fndecl, n, argarray);
10774 }
10775
10776 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...).  Duplicated because
10777    varargs macros aren't supported by all bootstrap compilers.  */
10778
10779 tree
10780 build_call_expr (tree fndecl, int n, ...)
10781 {
10782   va_list ap;
10783   tree *argarray = XALLOCAVEC (tree, n);
10784   int i;
10785
10786   va_start (ap, n);
10787   for (i = 0; i < n; i++)
10788     argarray[i] = va_arg (ap, tree);
10789   va_end (ap);
10790   return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
10791 }
10792
10793 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10794    N arguments are passed in the array ARGARRAY.  */
10795
10796 tree
10797 fold_builtin_call_array (location_t loc, tree type,
10798                          tree fn,
10799                          int n,
10800                          tree *argarray)
10801 {
10802   tree ret = NULL_TREE;
10803    tree exp;
10804
10805   if (TREE_CODE (fn) == ADDR_EXPR)
10806   {
10807     tree fndecl = TREE_OPERAND (fn, 0);
10808     if (TREE_CODE (fndecl) == FUNCTION_DECL
10809         && DECL_BUILT_IN (fndecl))
10810       {
10811         /* If last argument is __builtin_va_arg_pack (), arguments to this
10812            function are not finalized yet.  Defer folding until they are.  */
10813         if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
10814           {
10815             tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
10816             if (fndecl2
10817                 && TREE_CODE (fndecl2) == FUNCTION_DECL
10818                 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10819                 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10820               return build_call_array_loc (loc, type, fn, n, argarray);
10821           }
10822         if (avoid_folding_inline_builtin (fndecl))
10823           return build_call_array_loc (loc, type, fn, n, argarray);
10824         if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10825           {
10826             ret = targetm.fold_builtin (fndecl, n, argarray, false);
10827             if (ret)
10828               return ret;
10829
10830             return build_call_array_loc (loc, type, fn, n, argarray);
10831           }
10832         else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
10833           {
10834             /* First try the transformations that don't require consing up
10835                an exp.  */
10836             ret = fold_builtin_n (loc, fndecl, argarray, n, false);
10837             if (ret)
10838               return ret;
10839           }
10840
10841         /* If we got this far, we need to build an exp.  */
10842         exp = build_call_array_loc (loc, type, fn, n, argarray);
10843         ret = fold_builtin_varargs (loc, fndecl, exp, false);
10844         return ret ? ret : exp;
10845       }
10846   }
10847
10848   return build_call_array_loc (loc, type, fn, n, argarray);
10849 }
10850
10851 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10852    along with N new arguments specified as the "..." parameters.  SKIP
10853    is the number of arguments in EXP to be omitted.  This function is used
10854    to do varargs-to-varargs transformations.  */
10855
10856 static tree
10857 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
10858 {
10859   int oldnargs = call_expr_nargs (exp);
10860   int nargs = oldnargs - skip + n;
10861   tree fntype = TREE_TYPE (fndecl);
10862   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10863   tree *buffer;
10864
10865   if (n > 0)
10866     {
10867       int i, j;
10868       va_list ap;
10869
10870       buffer = XALLOCAVEC (tree, nargs);
10871       va_start (ap, n);
10872       for (i = 0; i < n; i++)
10873         buffer[i] = va_arg (ap, tree);
10874       va_end (ap);
10875       for (j = skip; j < oldnargs; j++, i++)
10876         buffer[i] = CALL_EXPR_ARG (exp, j);
10877     }
10878   else
10879     buffer = CALL_EXPR_ARGP (exp) + skip;
10880
10881   return fold (build_call_array_loc (loc, TREE_TYPE (exp), fn, nargs, buffer));
10882 }
10883
10884 /* Validate a single argument ARG against a tree code CODE representing
10885    a type.  */
10886
10887 static bool
10888 validate_arg (const_tree arg, enum tree_code code)
10889 {
10890   if (!arg)
10891     return false;
10892   else if (code == POINTER_TYPE)
10893     return POINTER_TYPE_P (TREE_TYPE (arg));
10894   else if (code == INTEGER_TYPE)
10895     return INTEGRAL_TYPE_P (TREE_TYPE (arg));
10896   return code == TREE_CODE (TREE_TYPE (arg));
10897 }
10898
10899 /* This function validates the types of a function call argument list
10900    against a specified list of tree_codes.  If the last specifier is a 0,
10901    that represents an ellipses, otherwise the last specifier must be a
10902    VOID_TYPE.
10903
10904    This is the GIMPLE version of validate_arglist.  Eventually we want to
10905    completely convert builtins.c to work from GIMPLEs and the tree based
10906    validate_arglist will then be removed.  */
10907
10908 bool
10909 validate_gimple_arglist (const_gimple call, ...)
10910 {
10911   enum tree_code code;
10912   bool res = 0;
10913   va_list ap;
10914   const_tree arg;
10915   size_t i;
10916
10917   va_start (ap, call);
10918   i = 0;
10919
10920   do
10921     {
10922       code = (enum tree_code) va_arg (ap, int);
10923       switch (code)
10924         {
10925         case 0:
10926           /* This signifies an ellipses, any further arguments are all ok.  */
10927           res = true;
10928           goto end;
10929         case VOID_TYPE:
10930           /* This signifies an endlink, if no arguments remain, return
10931              true, otherwise return false.  */
10932           res = (i == gimple_call_num_args (call));
10933           goto end;
10934         default:
10935           /* If no parameters remain or the parameter's code does not
10936              match the specified code, return false.  Otherwise continue
10937              checking any remaining arguments.  */
10938           arg = gimple_call_arg (call, i++);
10939           if (!validate_arg (arg, code))
10940             goto end;
10941           break;
10942         }
10943     }
10944   while (1);
10945
10946   /* We need gotos here since we can only have one VA_CLOSE in a
10947      function.  */
10948  end: ;
10949   va_end (ap);
10950
10951   return res;
10952 }
10953
10954 /* This function validates the types of a function call argument list
10955    against a specified list of tree_codes.  If the last specifier is a 0,
10956    that represents an ellipses, otherwise the last specifier must be a
10957    VOID_TYPE.  */
10958
10959 bool
10960 validate_arglist (const_tree callexpr, ...)
10961 {
10962   enum tree_code code;
10963   bool res = 0;
10964   va_list ap;
10965   const_call_expr_arg_iterator iter;
10966   const_tree arg;
10967
10968   va_start (ap, callexpr);
10969   init_const_call_expr_arg_iterator (callexpr, &iter);
10970
10971   do
10972     {
10973       code = (enum tree_code) va_arg (ap, int);
10974       switch (code)
10975         {
10976         case 0:
10977           /* This signifies an ellipses, any further arguments are all ok.  */
10978           res = true;
10979           goto end;
10980         case VOID_TYPE:
10981           /* This signifies an endlink, if no arguments remain, return
10982              true, otherwise return false.  */
10983           res = !more_const_call_expr_args_p (&iter);
10984           goto end;
10985         default:
10986           /* If no parameters remain or the parameter's code does not
10987              match the specified code, return false.  Otherwise continue
10988              checking any remaining arguments.  */
10989           arg = next_const_call_expr_arg (&iter);
10990           if (!validate_arg (arg, code))
10991             goto end;
10992           break;
10993         }
10994     }
10995   while (1);
10996
10997   /* We need gotos here since we can only have one VA_CLOSE in a
10998      function.  */
10999  end: ;
11000   va_end (ap);
11001
11002   return res;
11003 }
11004
11005 /* Default target-specific builtin expander that does nothing.  */
11006
11007 rtx
11008 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11009                         rtx target ATTRIBUTE_UNUSED,
11010                         rtx subtarget ATTRIBUTE_UNUSED,
11011                         enum machine_mode mode ATTRIBUTE_UNUSED,
11012                         int ignore ATTRIBUTE_UNUSED)
11013 {
11014   return NULL_RTX;
11015 }
11016
11017 /* Returns true is EXP represents data that would potentially reside
11018    in a readonly section.  */
11019
11020 static bool
11021 readonly_data_expr (tree exp)
11022 {
11023   STRIP_NOPS (exp);
11024
11025   if (TREE_CODE (exp) != ADDR_EXPR)
11026     return false;
11027
11028   exp = get_base_address (TREE_OPERAND (exp, 0));
11029   if (!exp)
11030     return false;
11031
11032   /* Make sure we call decl_readonly_section only for trees it
11033      can handle (since it returns true for everything it doesn't
11034      understand).  */
11035   if (TREE_CODE (exp) == STRING_CST
11036       || TREE_CODE (exp) == CONSTRUCTOR
11037       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11038     return decl_readonly_section (exp, 0);
11039   else
11040     return false;
11041 }
11042
11043 /* Simplify a call to the strstr builtin.  S1 and S2 are the arguments
11044    to the call, and TYPE is its return type.
11045
11046    Return NULL_TREE if no simplification was possible, otherwise return the
11047    simplified form of the call as a tree.
11048
11049    The simplified form may be a constant or other expression which
11050    computes the same value, but in a more efficient manner (including
11051    calls to other builtin functions).
11052
11053    The call may contain arguments which need to be evaluated, but
11054    which are not useful to determine the result of the call.  In
11055    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11056    COMPOUND_EXPR will be an argument which must be evaluated.
11057    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11058    COMPOUND_EXPR in the chain will contain the tree for the simplified
11059    form of the builtin function call.  */
11060
11061 static tree
11062 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11063 {
11064   if (!validate_arg (s1, POINTER_TYPE)
11065       || !validate_arg (s2, POINTER_TYPE))
11066     return NULL_TREE;
11067   else
11068     {
11069       tree fn;
11070       const char *p1, *p2;
11071
11072       p2 = c_getstr (s2);
11073       if (p2 == NULL)
11074         return NULL_TREE;
11075
11076       p1 = c_getstr (s1);
11077       if (p1 != NULL)
11078         {
11079           const char *r = strstr (p1, p2);
11080           tree tem;
11081
11082           if (r == NULL)
11083             return build_int_cst (TREE_TYPE (s1), 0);
11084
11085           /* Return an offset into the constant string argument.  */
11086           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11087                              s1, size_int (r - p1));
11088           return fold_convert_loc (loc, type, tem);
11089         }
11090
11091       /* The argument is const char *, and the result is char *, so we need
11092          a type conversion here to avoid a warning.  */
11093       if (p2[0] == '\0')
11094         return fold_convert_loc (loc, type, s1);
11095
11096       if (p2[1] != '\0')
11097         return NULL_TREE;
11098
11099       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11100       if (!fn)
11101         return NULL_TREE;
11102
11103       /* New argument list transforming strstr(s1, s2) to
11104          strchr(s1, s2[0]).  */
11105       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11106     }
11107 }
11108
11109 /* Simplify a call to the strchr builtin.  S1 and S2 are the arguments to
11110    the call, and TYPE is its return type.
11111
11112    Return NULL_TREE if no simplification was possible, otherwise return the
11113    simplified form of the call as a tree.
11114
11115    The simplified form may be a constant or other expression which
11116    computes the same value, but in a more efficient manner (including
11117    calls to other builtin functions).
11118
11119    The call may contain arguments which need to be evaluated, but
11120    which are not useful to determine the result of the call.  In
11121    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11122    COMPOUND_EXPR will be an argument which must be evaluated.
11123    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11124    COMPOUND_EXPR in the chain will contain the tree for the simplified
11125    form of the builtin function call.  */
11126
11127 static tree
11128 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11129 {
11130   if (!validate_arg (s1, POINTER_TYPE)
11131       || !validate_arg (s2, INTEGER_TYPE))
11132     return NULL_TREE;
11133   else
11134     {
11135       const char *p1;
11136
11137       if (TREE_CODE (s2) != INTEGER_CST)
11138         return NULL_TREE;
11139
11140       p1 = c_getstr (s1);
11141       if (p1 != NULL)
11142         {
11143           char c;
11144           const char *r;
11145           tree tem;
11146
11147           if (target_char_cast (s2, &c))
11148             return NULL_TREE;
11149
11150           r = strchr (p1, c);
11151
11152           if (r == NULL)
11153             return build_int_cst (TREE_TYPE (s1), 0);
11154
11155           /* Return an offset into the constant string argument.  */
11156           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11157                              s1, size_int (r - p1));
11158           return fold_convert_loc (loc, type, tem);
11159         }
11160       return NULL_TREE;
11161     }
11162 }
11163
11164 /* Simplify a call to the strrchr builtin.  S1 and S2 are the arguments to
11165    the call, and TYPE is its return type.
11166
11167    Return NULL_TREE if no simplification was possible, otherwise return the
11168    simplified form of the call as a tree.
11169
11170    The simplified form may be a constant or other expression which
11171    computes the same value, but in a more efficient manner (including
11172    calls to other builtin functions).
11173
11174    The call may contain arguments which need to be evaluated, but
11175    which are not useful to determine the result of the call.  In
11176    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11177    COMPOUND_EXPR will be an argument which must be evaluated.
11178    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11179    COMPOUND_EXPR in the chain will contain the tree for the simplified
11180    form of the builtin function call.  */
11181
11182 static tree
11183 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11184 {
11185   if (!validate_arg (s1, POINTER_TYPE)
11186       || !validate_arg (s2, INTEGER_TYPE))
11187     return NULL_TREE;
11188   else
11189     {
11190       tree fn;
11191       const char *p1;
11192
11193       if (TREE_CODE (s2) != INTEGER_CST)
11194         return NULL_TREE;
11195
11196       p1 = c_getstr (s1);
11197       if (p1 != NULL)
11198         {
11199           char c;
11200           const char *r;
11201           tree tem;
11202
11203           if (target_char_cast (s2, &c))
11204             return NULL_TREE;
11205
11206           r = strrchr (p1, c);
11207
11208           if (r == NULL)
11209             return build_int_cst (TREE_TYPE (s1), 0);
11210
11211           /* Return an offset into the constant string argument.  */
11212           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11213                              s1, size_int (r - p1));
11214           return fold_convert_loc (loc, type, tem);
11215         }
11216
11217       if (! integer_zerop (s2))
11218         return NULL_TREE;
11219
11220       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11221       if (!fn)
11222         return NULL_TREE;
11223
11224       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
11225       return build_call_expr_loc (loc, fn, 2, s1, s2);
11226     }
11227 }
11228
11229 /* Simplify a call to the strpbrk builtin.  S1 and S2 are the arguments
11230    to the call, and TYPE is its return type.
11231
11232    Return NULL_TREE if no simplification was possible, otherwise return the
11233    simplified form of the call as a tree.
11234
11235    The simplified form may be a constant or other expression which
11236    computes the same value, but in a more efficient manner (including
11237    calls to other builtin functions).
11238
11239    The call may contain arguments which need to be evaluated, but
11240    which are not useful to determine the result of the call.  In
11241    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11242    COMPOUND_EXPR will be an argument which must be evaluated.
11243    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11244    COMPOUND_EXPR in the chain will contain the tree for the simplified
11245    form of the builtin function call.  */
11246
11247 static tree
11248 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11249 {
11250   if (!validate_arg (s1, POINTER_TYPE)
11251       || !validate_arg (s2, POINTER_TYPE))
11252     return NULL_TREE;
11253   else
11254     {
11255       tree fn;
11256       const char *p1, *p2;
11257
11258       p2 = c_getstr (s2);
11259       if (p2 == NULL)
11260         return NULL_TREE;
11261
11262       p1 = c_getstr (s1);
11263       if (p1 != NULL)
11264         {
11265           const char *r = strpbrk (p1, p2);
11266           tree tem;
11267
11268           if (r == NULL)
11269             return build_int_cst (TREE_TYPE (s1), 0);
11270
11271           /* Return an offset into the constant string argument.  */
11272           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11273                              s1, size_int (r - p1));
11274           return fold_convert_loc (loc, type, tem);
11275         }
11276
11277       if (p2[0] == '\0')
11278         /* strpbrk(x, "") == NULL.
11279            Evaluate and ignore s1 in case it had side-effects.  */
11280         return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11281
11282       if (p2[1] != '\0')
11283         return NULL_TREE;  /* Really call strpbrk.  */
11284
11285       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11286       if (!fn)
11287         return NULL_TREE;
11288
11289       /* New argument list transforming strpbrk(s1, s2) to
11290          strchr(s1, s2[0]).  */
11291       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11292     }
11293 }
11294
11295 /* Simplify a call to the strcat builtin.  DST and SRC are the arguments
11296    to the call.
11297
11298    Return NULL_TREE if no simplification was possible, otherwise return the
11299    simplified form of the call as a tree.
11300
11301    The simplified form may be a constant or other expression which
11302    computes the same value, but in a more efficient manner (including
11303    calls to other builtin functions).
11304
11305    The call may contain arguments which need to be evaluated, but
11306    which are not useful to determine the result of the call.  In
11307    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11308    COMPOUND_EXPR will be an argument which must be evaluated.
11309    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11310    COMPOUND_EXPR in the chain will contain the tree for the simplified
11311    form of the builtin function call.  */
11312
11313 static tree
11314 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11315 {
11316   if (!validate_arg (dst, POINTER_TYPE)
11317       || !validate_arg (src, POINTER_TYPE))
11318     return NULL_TREE;
11319   else
11320     {
11321       const char *p = c_getstr (src);
11322
11323       /* If the string length is zero, return the dst parameter.  */
11324       if (p && *p == '\0')
11325         return dst;
11326
11327       if (optimize_insn_for_speed_p ())
11328         {
11329           /* See if we can store by pieces into (dst + strlen(dst)).  */
11330           tree newdst, call;
11331           tree strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11332           tree strcpy_fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11333
11334           if (!strlen_fn || !strcpy_fn)
11335             return NULL_TREE;
11336
11337           /* If we don't have a movstr we don't want to emit an strcpy
11338              call.  We have to do that if the length of the source string
11339              isn't computable (in that case we can use memcpy probably
11340              later expanding to a sequence of mov instructions).  If we
11341              have movstr instructions we can emit strcpy calls.  */
11342           if (!HAVE_movstr)
11343             {
11344               tree len = c_strlen (src, 1);
11345               if (! len || TREE_SIDE_EFFECTS (len))
11346                 return NULL_TREE;
11347             }
11348
11349           /* Stabilize the argument list.  */
11350           dst = builtin_save_expr (dst);
11351
11352           /* Create strlen (dst).  */
11353           newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11354           /* Create (dst p+ strlen (dst)).  */
11355
11356           newdst = fold_build2_loc (loc, POINTER_PLUS_EXPR,
11357                                 TREE_TYPE (dst), dst, newdst);
11358           newdst = builtin_save_expr (newdst);
11359
11360           call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11361           return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11362         }
11363       return NULL_TREE;
11364     }
11365 }
11366
11367 /* Simplify a call to the strncat builtin.  DST, SRC, and LEN are the
11368    arguments to the call.
11369
11370    Return NULL_TREE if no simplification was possible, otherwise return the
11371    simplified form of the call as a tree.
11372
11373    The simplified form may be a constant or other expression which
11374    computes the same value, but in a more efficient manner (including
11375    calls to other builtin functions).
11376
11377    The call may contain arguments which need to be evaluated, but
11378    which are not useful to determine the result of the call.  In
11379    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11380    COMPOUND_EXPR will be an argument which must be evaluated.
11381    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11382    COMPOUND_EXPR in the chain will contain the tree for the simplified
11383    form of the builtin function call.  */
11384
11385 static tree
11386 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11387 {
11388   if (!validate_arg (dst, POINTER_TYPE)
11389       || !validate_arg (src, POINTER_TYPE)
11390       || !validate_arg (len, INTEGER_TYPE))
11391     return NULL_TREE;
11392   else
11393     {
11394       const char *p = c_getstr (src);
11395
11396       /* If the requested length is zero, or the src parameter string
11397          length is zero, return the dst parameter.  */
11398       if (integer_zerop (len) || (p && *p == '\0'))
11399         return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11400
11401       /* If the requested len is greater than or equal to the string
11402          length, call strcat.  */
11403       if (TREE_CODE (len) == INTEGER_CST && p
11404           && compare_tree_int (len, strlen (p)) >= 0)
11405         {
11406           tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
11407
11408           /* If the replacement _DECL isn't initialized, don't do the
11409              transformation.  */
11410           if (!fn)
11411             return NULL_TREE;
11412
11413           return build_call_expr_loc (loc, fn, 2, dst, src);
11414         }
11415       return NULL_TREE;
11416     }
11417 }
11418
11419 /* Simplify a call to the strspn builtin.  S1 and S2 are the arguments
11420    to the call.
11421
11422    Return NULL_TREE if no simplification was possible, otherwise return the
11423    simplified form of the call as a tree.
11424
11425    The simplified form may be a constant or other expression which
11426    computes the same value, but in a more efficient manner (including
11427    calls to other builtin functions).
11428
11429    The call may contain arguments which need to be evaluated, but
11430    which are not useful to determine the result of the call.  In
11431    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11432    COMPOUND_EXPR will be an argument which must be evaluated.
11433    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11434    COMPOUND_EXPR in the chain will contain the tree for the simplified
11435    form of the builtin function call.  */
11436
11437 static tree
11438 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11439 {
11440   if (!validate_arg (s1, POINTER_TYPE)
11441       || !validate_arg (s2, POINTER_TYPE))
11442     return NULL_TREE;
11443   else
11444     {
11445       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11446
11447       /* If both arguments are constants, evaluate at compile-time.  */
11448       if (p1 && p2)
11449         {
11450           const size_t r = strspn (p1, p2);
11451           return size_int (r);
11452         }
11453
11454       /* If either argument is "", return NULL_TREE.  */
11455       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11456         /* Evaluate and ignore both arguments in case either one has
11457            side-effects.  */
11458         return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11459                                   s1, s2);
11460       return NULL_TREE;
11461     }
11462 }
11463
11464 /* Simplify a call to the strcspn builtin.  S1 and S2 are the arguments
11465    to the call.
11466
11467    Return NULL_TREE if no simplification was possible, otherwise return the
11468    simplified form of the call as a tree.
11469
11470    The simplified form may be a constant or other expression which
11471    computes the same value, but in a more efficient manner (including
11472    calls to other builtin functions).
11473
11474    The call may contain arguments which need to be evaluated, but
11475    which are not useful to determine the result of the call.  In
11476    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11477    COMPOUND_EXPR will be an argument which must be evaluated.
11478    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11479    COMPOUND_EXPR in the chain will contain the tree for the simplified
11480    form of the builtin function call.  */
11481
11482 static tree
11483 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11484 {
11485   if (!validate_arg (s1, POINTER_TYPE)
11486       || !validate_arg (s2, POINTER_TYPE))
11487     return NULL_TREE;
11488   else
11489     {
11490       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11491
11492       /* If both arguments are constants, evaluate at compile-time.  */
11493       if (p1 && p2)
11494         {
11495           const size_t r = strcspn (p1, p2);
11496           return size_int (r);
11497         }
11498
11499       /* If the first argument is "", return NULL_TREE.  */
11500       if (p1 && *p1 == '\0')
11501         {
11502           /* Evaluate and ignore argument s2 in case it has
11503              side-effects.  */
11504           return omit_one_operand_loc (loc, size_type_node,
11505                                    size_zero_node, s2);
11506         }
11507
11508       /* If the second argument is "", return __builtin_strlen(s1).  */
11509       if (p2 && *p2 == '\0')
11510         {
11511           tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11512
11513           /* If the replacement _DECL isn't initialized, don't do the
11514              transformation.  */
11515           if (!fn)
11516             return NULL_TREE;
11517
11518           return build_call_expr_loc (loc, fn, 1, s1);
11519         }
11520       return NULL_TREE;
11521     }
11522 }
11523
11524 /* Fold a call to the fputs builtin.  ARG0 and ARG1 are the arguments
11525    to the call.  IGNORE is true if the value returned
11526    by the builtin will be ignored.  UNLOCKED is true is true if this
11527    actually a call to fputs_unlocked.  If LEN in non-NULL, it represents
11528    the known length of the string.  Return NULL_TREE if no simplification
11529    was possible.  */
11530
11531 tree
11532 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
11533                     bool ignore, bool unlocked, tree len)
11534 {
11535   /* If we're using an unlocked function, assume the other unlocked
11536      functions exist explicitly.  */
11537   tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
11538     : implicit_built_in_decls[BUILT_IN_FPUTC];
11539   tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
11540     : implicit_built_in_decls[BUILT_IN_FWRITE];
11541
11542   /* If the return value is used, don't do the transformation.  */
11543   if (!ignore)
11544     return NULL_TREE;
11545
11546   /* Verify the arguments in the original call.  */
11547   if (!validate_arg (arg0, POINTER_TYPE)
11548       || !validate_arg (arg1, POINTER_TYPE))
11549     return NULL_TREE;
11550
11551   if (! len)
11552     len = c_strlen (arg0, 0);
11553
11554   /* Get the length of the string passed to fputs.  If the length
11555      can't be determined, punt.  */
11556   if (!len
11557       || TREE_CODE (len) != INTEGER_CST)
11558     return NULL_TREE;
11559
11560   switch (compare_tree_int (len, 1))
11561     {
11562     case -1: /* length is 0, delete the call entirely .  */
11563       return omit_one_operand_loc (loc, integer_type_node,
11564                                integer_zero_node, arg1);;
11565
11566     case 0: /* length is 1, call fputc.  */
11567       {
11568         const char *p = c_getstr (arg0);
11569
11570         if (p != NULL)
11571           {
11572             if (fn_fputc)
11573               return build_call_expr_loc (loc, fn_fputc, 2,
11574                                       build_int_cst (NULL_TREE, p[0]), arg1);
11575             else
11576               return NULL_TREE;
11577           }
11578       }
11579       /* FALLTHROUGH */
11580     case 1: /* length is greater than 1, call fwrite.  */
11581       {
11582         /* If optimizing for size keep fputs.  */
11583         if (optimize_function_for_size_p (cfun))
11584           return NULL_TREE;
11585         /* New argument list transforming fputs(string, stream) to
11586            fwrite(string, 1, len, stream).  */
11587         if (fn_fwrite)
11588           return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
11589                                   size_one_node, len, arg1);
11590         else
11591           return NULL_TREE;
11592       }
11593     default:
11594       gcc_unreachable ();
11595     }
11596   return NULL_TREE;
11597 }
11598
11599 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11600    produced.  False otherwise.  This is done so that we don't output the error
11601    or warning twice or three times.  */
11602
11603 bool
11604 fold_builtin_next_arg (tree exp, bool va_start_p)
11605 {
11606   tree fntype = TREE_TYPE (current_function_decl);
11607   int nargs = call_expr_nargs (exp);
11608   tree arg;
11609
11610   if (!stdarg_p (fntype))
11611     {
11612       error ("%<va_start%> used in function with fixed args");
11613       return true;
11614     }
11615
11616   if (va_start_p)
11617     {
11618       if (va_start_p && (nargs != 2))
11619         {
11620           error ("wrong number of arguments to function %<va_start%>");
11621           return true;
11622         }
11623       arg = CALL_EXPR_ARG (exp, 1);
11624     }
11625   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11626      when we checked the arguments and if needed issued a warning.  */
11627   else
11628     {
11629       if (nargs == 0)
11630         {
11631           /* Evidently an out of date version of <stdarg.h>; can't validate
11632              va_start's second argument, but can still work as intended.  */
11633           warning (0, "%<__builtin_next_arg%> called without an argument");
11634           return true;
11635         }
11636       else if (nargs > 1)
11637         {
11638           error ("wrong number of arguments to function %<__builtin_next_arg%>");
11639           return true;
11640         }
11641       arg = CALL_EXPR_ARG (exp, 0);
11642     }
11643
11644   if (TREE_CODE (arg) == SSA_NAME)
11645     arg = SSA_NAME_VAR (arg);
11646
11647   /* We destructively modify the call to be __builtin_va_start (ap, 0)
11648      or __builtin_next_arg (0) the first time we see it, after checking
11649      the arguments and if needed issuing a warning.  */
11650   if (!integer_zerop (arg))
11651     {
11652       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
11653
11654       /* Strip off all nops for the sake of the comparison.  This
11655          is not quite the same as STRIP_NOPS.  It does more.
11656          We must also strip off INDIRECT_EXPR for C++ reference
11657          parameters.  */
11658       while (CONVERT_EXPR_P (arg)
11659              || TREE_CODE (arg) == INDIRECT_REF)
11660         arg = TREE_OPERAND (arg, 0);
11661       if (arg != last_parm)
11662         {
11663           /* FIXME: Sometimes with the tree optimizers we can get the
11664              not the last argument even though the user used the last
11665              argument.  We just warn and set the arg to be the last
11666              argument so that we will get wrong-code because of
11667              it.  */
11668           warning (0, "second parameter of %<va_start%> not last named argument");
11669         }
11670
11671       /* Undefined by C99 7.15.1.4p4 (va_start):
11672          "If the parameter parmN is declared with the register storage
11673          class, with a function or array type, or with a type that is
11674          not compatible with the type that results after application of
11675          the default argument promotions, the behavior is undefined."
11676       */
11677       else if (DECL_REGISTER (arg))
11678         warning (0, "undefined behaviour when second parameter of "
11679                  "%<va_start%> is declared with %<register%> storage");
11680
11681       /* We want to verify the second parameter just once before the tree
11682          optimizers are run and then avoid keeping it in the tree,
11683          as otherwise we could warn even for correct code like:
11684          void foo (int i, ...)
11685          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
11686       if (va_start_p)
11687         CALL_EXPR_ARG (exp, 1) = integer_zero_node;
11688       else
11689         CALL_EXPR_ARG (exp, 0) = integer_zero_node;
11690     }
11691   return false;
11692 }
11693
11694
11695 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11696    ORIG may be null if this is a 2-argument call.  We don't attempt to
11697    simplify calls with more than 3 arguments.
11698
11699    Return NULL_TREE if no simplification was possible, otherwise return the
11700    simplified form of the call as a tree.  If IGNORED is true, it means that
11701    the caller does not use the returned value of the function.  */
11702
11703 static tree
11704 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
11705                       tree orig, int ignored)
11706 {
11707   tree call, retval;
11708   const char *fmt_str = NULL;
11709
11710   /* Verify the required arguments in the original call.  We deal with two
11711      types of sprintf() calls: 'sprintf (str, fmt)' and
11712      'sprintf (dest, "%s", orig)'.  */
11713   if (!validate_arg (dest, POINTER_TYPE)
11714       || !validate_arg (fmt, POINTER_TYPE))
11715     return NULL_TREE;
11716   if (orig && !validate_arg (orig, POINTER_TYPE))
11717     return NULL_TREE;
11718
11719   /* Check whether the format is a literal string constant.  */
11720   fmt_str = c_getstr (fmt);
11721   if (fmt_str == NULL)
11722     return NULL_TREE;
11723
11724   call = NULL_TREE;
11725   retval = NULL_TREE;
11726
11727   if (!init_target_chars ())
11728     return NULL_TREE;
11729
11730   /* If the format doesn't contain % args or %%, use strcpy.  */
11731   if (strchr (fmt_str, target_percent) == NULL)
11732     {
11733       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11734
11735       if (!fn)
11736         return NULL_TREE;
11737
11738       /* Don't optimize sprintf (buf, "abc", ptr++).  */
11739       if (orig)
11740         return NULL_TREE;
11741
11742       /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11743          'format' is known to contain no % formats.  */
11744       call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11745       if (!ignored)
11746         retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11747     }
11748
11749   /* If the format is "%s", use strcpy if the result isn't used.  */
11750   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11751     {
11752       tree fn;
11753       fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11754
11755       if (!fn)
11756         return NULL_TREE;
11757
11758       /* Don't crash on sprintf (str1, "%s").  */
11759       if (!orig)
11760         return NULL_TREE;
11761
11762       /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2).  */
11763       if (!ignored)
11764         {
11765           retval = c_strlen (orig, 1);
11766           if (!retval || TREE_CODE (retval) != INTEGER_CST)
11767             return NULL_TREE;
11768         }
11769       call = build_call_expr_loc (loc, fn, 2, dest, orig);
11770     }
11771
11772   if (call && retval)
11773     {
11774       retval = fold_convert_loc
11775         (loc, TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
11776          retval);
11777       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11778     }
11779   else
11780     return call;
11781 }
11782
11783 /* Expand a call EXP to __builtin_object_size.  */
11784
11785 rtx
11786 expand_builtin_object_size (tree exp)
11787 {
11788   tree ost;
11789   int object_size_type;
11790   tree fndecl = get_callee_fndecl (exp);
11791
11792   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
11793     {
11794       error ("%Kfirst argument of %D must be a pointer, second integer constant",
11795              exp, fndecl);
11796       expand_builtin_trap ();
11797       return const0_rtx;
11798     }
11799
11800   ost = CALL_EXPR_ARG (exp, 1);
11801   STRIP_NOPS (ost);
11802
11803   if (TREE_CODE (ost) != INTEGER_CST
11804       || tree_int_cst_sgn (ost) < 0
11805       || compare_tree_int (ost, 3) > 0)
11806     {
11807       error ("%Klast argument of %D is not integer constant between 0 and 3",
11808              exp, fndecl);
11809       expand_builtin_trap ();
11810       return const0_rtx;
11811     }
11812
11813   object_size_type = tree_low_cst (ost, 0);
11814
11815   return object_size_type < 2 ? constm1_rtx : const0_rtx;
11816 }
11817
11818 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11819    FCODE is the BUILT_IN_* to use.
11820    Return NULL_RTX if we failed; the caller should emit a normal call,
11821    otherwise try to get the result in TARGET, if convenient (and in
11822    mode MODE if that's convenient).  */
11823
11824 static rtx
11825 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
11826                            enum built_in_function fcode)
11827 {
11828   tree dest, src, len, size;
11829
11830   if (!validate_arglist (exp,
11831                          POINTER_TYPE,
11832                          fcode == BUILT_IN_MEMSET_CHK
11833                          ? INTEGER_TYPE : POINTER_TYPE,
11834                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
11835     return NULL_RTX;
11836
11837   dest = CALL_EXPR_ARG (exp, 0);
11838   src = CALL_EXPR_ARG (exp, 1);
11839   len = CALL_EXPR_ARG (exp, 2);
11840   size = CALL_EXPR_ARG (exp, 3);
11841
11842   if (! host_integerp (size, 1))
11843     return NULL_RTX;
11844
11845   if (host_integerp (len, 1) || integer_all_onesp (size))
11846     {
11847       tree fn;
11848
11849       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
11850         {
11851           warning_at (tree_nonartificial_location (exp),
11852                       0, "%Kcall to %D will always overflow destination buffer",
11853                       exp, get_callee_fndecl (exp));
11854           return NULL_RTX;
11855         }
11856
11857       fn = NULL_TREE;
11858       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11859          mem{cpy,pcpy,move,set} is available.  */
11860       switch (fcode)
11861         {
11862         case BUILT_IN_MEMCPY_CHK:
11863           fn = built_in_decls[BUILT_IN_MEMCPY];
11864           break;
11865         case BUILT_IN_MEMPCPY_CHK:
11866           fn = built_in_decls[BUILT_IN_MEMPCPY];
11867           break;
11868         case BUILT_IN_MEMMOVE_CHK:
11869           fn = built_in_decls[BUILT_IN_MEMMOVE];
11870           break;
11871         case BUILT_IN_MEMSET_CHK:
11872           fn = built_in_decls[BUILT_IN_MEMSET];
11873           break;
11874         default:
11875           break;
11876         }
11877
11878       if (! fn)
11879         return NULL_RTX;
11880
11881       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
11882       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
11883       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11884       return expand_expr (fn, target, mode, EXPAND_NORMAL);
11885     }
11886   else if (fcode == BUILT_IN_MEMSET_CHK)
11887     return NULL_RTX;
11888   else
11889     {
11890       unsigned int dest_align
11891         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
11892
11893       /* If DEST is not a pointer type, call the normal function.  */
11894       if (dest_align == 0)
11895         return NULL_RTX;
11896
11897       /* If SRC and DEST are the same (and not volatile), do nothing.  */
11898       if (operand_equal_p (src, dest, 0))
11899         {
11900           tree expr;
11901
11902           if (fcode != BUILT_IN_MEMPCPY_CHK)
11903             {
11904               /* Evaluate and ignore LEN in case it has side-effects.  */
11905               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
11906               return expand_expr (dest, target, mode, EXPAND_NORMAL);
11907             }
11908
11909           expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
11910           return expand_expr (expr, target, mode, EXPAND_NORMAL);
11911         }
11912
11913       /* __memmove_chk special case.  */
11914       if (fcode == BUILT_IN_MEMMOVE_CHK)
11915         {
11916           unsigned int src_align
11917             = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
11918
11919           if (src_align == 0)
11920             return NULL_RTX;
11921
11922           /* If src is categorized for a readonly section we can use
11923              normal __memcpy_chk.  */
11924           if (readonly_data_expr (src))
11925             {
11926               tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
11927               if (!fn)
11928                 return NULL_RTX;
11929               fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
11930                                           dest, src, len, size);
11931               gcc_assert (TREE_CODE (fn) == CALL_EXPR);
11932               CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11933               return expand_expr (fn, target, mode, EXPAND_NORMAL);
11934             }
11935         }
11936       return NULL_RTX;
11937     }
11938 }
11939
11940 /* Emit warning if a buffer overflow is detected at compile time.  */
11941
11942 static void
11943 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
11944 {
11945   int is_strlen = 0;
11946   tree len, size;
11947   location_t loc = tree_nonartificial_location (exp);
11948
11949   switch (fcode)
11950     {
11951     case BUILT_IN_STRCPY_CHK:
11952     case BUILT_IN_STPCPY_CHK:
11953     /* For __strcat_chk the warning will be emitted only if overflowing
11954        by at least strlen (dest) + 1 bytes.  */
11955     case BUILT_IN_STRCAT_CHK:
11956       len = CALL_EXPR_ARG (exp, 1);
11957       size = CALL_EXPR_ARG (exp, 2);
11958       is_strlen = 1;
11959       break;
11960     case BUILT_IN_STRNCAT_CHK:
11961     case BUILT_IN_STRNCPY_CHK:
11962       len = CALL_EXPR_ARG (exp, 2);
11963       size = CALL_EXPR_ARG (exp, 3);
11964       break;
11965     case BUILT_IN_SNPRINTF_CHK:
11966     case BUILT_IN_VSNPRINTF_CHK:
11967       len = CALL_EXPR_ARG (exp, 1);
11968       size = CALL_EXPR_ARG (exp, 3);
11969       break;
11970     default:
11971       gcc_unreachable ();
11972     }
11973
11974   if (!len || !size)
11975     return;
11976
11977   if (! host_integerp (size, 1) || integer_all_onesp (size))
11978     return;
11979
11980   if (is_strlen)
11981     {
11982       len = c_strlen (len, 1);
11983       if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
11984         return;
11985     }
11986   else if (fcode == BUILT_IN_STRNCAT_CHK)
11987     {
11988       tree src = CALL_EXPR_ARG (exp, 1);
11989       if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
11990         return;
11991       src = c_strlen (src, 1);
11992       if (! src || ! host_integerp (src, 1))
11993         {
11994           warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
11995                       exp, get_callee_fndecl (exp));
11996           return;
11997         }
11998       else if (tree_int_cst_lt (src, size))
11999         return;
12000     }
12001   else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12002     return;
12003
12004   warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12005               exp, get_callee_fndecl (exp));
12006 }
12007
12008 /* Emit warning if a buffer overflow is detected at compile time
12009    in __sprintf_chk/__vsprintf_chk calls.  */
12010
12011 static void
12012 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12013 {
12014   tree size, len, fmt;
12015   const char *fmt_str;
12016   int nargs = call_expr_nargs (exp);
12017
12018   /* Verify the required arguments in the original call.  */
12019
12020   if (nargs < 4)
12021     return;
12022   size = CALL_EXPR_ARG (exp, 2);
12023   fmt = CALL_EXPR_ARG (exp, 3);
12024
12025   if (! host_integerp (size, 1) || integer_all_onesp (size))
12026     return;
12027
12028   /* Check whether the format is a literal string constant.  */
12029   fmt_str = c_getstr (fmt);
12030   if (fmt_str == NULL)
12031     return;
12032
12033   if (!init_target_chars ())
12034     return;
12035
12036   /* If the format doesn't contain % args or %%, we know its size.  */
12037   if (strchr (fmt_str, target_percent) == 0)
12038     len = build_int_cstu (size_type_node, strlen (fmt_str));
12039   /* If the format is "%s" and first ... argument is a string literal,
12040      we know it too.  */
12041   else if (fcode == BUILT_IN_SPRINTF_CHK
12042            && strcmp (fmt_str, target_percent_s) == 0)
12043     {
12044       tree arg;
12045
12046       if (nargs < 5)
12047         return;
12048       arg = CALL_EXPR_ARG (exp, 4);
12049       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12050         return;
12051
12052       len = c_strlen (arg, 1);
12053       if (!len || ! host_integerp (len, 1))
12054         return;
12055     }
12056   else
12057     return;
12058
12059   if (! tree_int_cst_lt (len, size))
12060     warning_at (tree_nonartificial_location (exp),
12061                 0, "%Kcall to %D will always overflow destination buffer",
12062                 exp, get_callee_fndecl (exp));
12063 }
12064
12065 /* Emit warning if a free is called with address of a variable.  */
12066
12067 static void
12068 maybe_emit_free_warning (tree exp)
12069 {
12070   tree arg = CALL_EXPR_ARG (exp, 0);
12071
12072   STRIP_NOPS (arg);
12073   if (TREE_CODE (arg) != ADDR_EXPR)
12074     return;
12075
12076   arg = get_base_address (TREE_OPERAND (arg, 0));
12077   if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
12078     return;
12079
12080   if (SSA_VAR_P (arg))
12081     warning_at (tree_nonartificial_location (exp),
12082                 0, "%Kattempt to free a non-heap object %qD", exp, arg);
12083   else
12084     warning_at (tree_nonartificial_location (exp),
12085                 0, "%Kattempt to free a non-heap object", exp);
12086 }
12087
12088 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12089    if possible.  */
12090
12091 tree
12092 fold_builtin_object_size (tree ptr, tree ost)
12093 {
12094   unsigned HOST_WIDE_INT bytes;
12095   int object_size_type;
12096
12097   if (!validate_arg (ptr, POINTER_TYPE)
12098       || !validate_arg (ost, INTEGER_TYPE))
12099     return NULL_TREE;
12100
12101   STRIP_NOPS (ost);
12102
12103   if (TREE_CODE (ost) != INTEGER_CST
12104       || tree_int_cst_sgn (ost) < 0
12105       || compare_tree_int (ost, 3) > 0)
12106     return NULL_TREE;
12107
12108   object_size_type = tree_low_cst (ost, 0);
12109
12110   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12111      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12112      and (size_t) 0 for types 2 and 3.  */
12113   if (TREE_SIDE_EFFECTS (ptr))
12114     return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12115
12116   if (TREE_CODE (ptr) == ADDR_EXPR)
12117     {
12118       bytes = compute_builtin_object_size (ptr, object_size_type);
12119       if (double_int_fits_to_tree_p (size_type_node,
12120                                      uhwi_to_double_int (bytes)))
12121         return build_int_cstu (size_type_node, bytes);
12122     }
12123   else if (TREE_CODE (ptr) == SSA_NAME)
12124     {
12125       /* If object size is not known yet, delay folding until
12126        later.  Maybe subsequent passes will help determining
12127        it.  */
12128       bytes = compute_builtin_object_size (ptr, object_size_type);
12129       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
12130           && double_int_fits_to_tree_p (size_type_node,
12131                                         uhwi_to_double_int (bytes)))
12132         return build_int_cstu (size_type_node, bytes);
12133     }
12134
12135   return NULL_TREE;
12136 }
12137
12138 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12139    DEST, SRC, LEN, and SIZE are the arguments to the call.
12140    IGNORE is true, if return value can be ignored.  FCODE is the BUILT_IN_*
12141    code of the builtin.  If MAXLEN is not NULL, it is maximum length
12142    passed as third argument.  */
12143
12144 tree
12145 fold_builtin_memory_chk (location_t loc, tree fndecl,
12146                          tree dest, tree src, tree len, tree size,
12147                          tree maxlen, bool ignore,
12148                          enum built_in_function fcode)
12149 {
12150   tree fn;
12151
12152   if (!validate_arg (dest, POINTER_TYPE)
12153       || !validate_arg (src,
12154                         (fcode == BUILT_IN_MEMSET_CHK
12155                          ? INTEGER_TYPE : POINTER_TYPE))
12156       || !validate_arg (len, INTEGER_TYPE)
12157       || !validate_arg (size, INTEGER_TYPE))
12158     return NULL_TREE;
12159
12160   /* If SRC and DEST are the same (and not volatile), return DEST
12161      (resp. DEST+LEN for __mempcpy_chk).  */
12162   if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12163     {
12164       if (fcode != BUILT_IN_MEMPCPY_CHK)
12165         return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12166                                  dest, len);
12167       else
12168         {
12169           tree temp = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest),
12170                                    dest, len);
12171           return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12172         }
12173     }
12174
12175   if (! host_integerp (size, 1))
12176     return NULL_TREE;
12177
12178   if (! integer_all_onesp (size))
12179     {
12180       if (! host_integerp (len, 1))
12181         {
12182           /* If LEN is not constant, try MAXLEN too.
12183              For MAXLEN only allow optimizing into non-_ocs function
12184              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12185           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12186             {
12187               if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12188                 {
12189                   /* (void) __mempcpy_chk () can be optimized into
12190                      (void) __memcpy_chk ().  */
12191                   fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12192                   if (!fn)
12193                     return NULL_TREE;
12194
12195                   return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12196                 }
12197               return NULL_TREE;
12198             }
12199         }
12200       else
12201         maxlen = len;
12202
12203       if (tree_int_cst_lt (size, maxlen))
12204         return NULL_TREE;
12205     }
12206
12207   fn = NULL_TREE;
12208   /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12209      mem{cpy,pcpy,move,set} is available.  */
12210   switch (fcode)
12211     {
12212     case BUILT_IN_MEMCPY_CHK:
12213       fn = built_in_decls[BUILT_IN_MEMCPY];
12214       break;
12215     case BUILT_IN_MEMPCPY_CHK:
12216       fn = built_in_decls[BUILT_IN_MEMPCPY];
12217       break;
12218     case BUILT_IN_MEMMOVE_CHK:
12219       fn = built_in_decls[BUILT_IN_MEMMOVE];
12220       break;
12221     case BUILT_IN_MEMSET_CHK:
12222       fn = built_in_decls[BUILT_IN_MEMSET];
12223       break;
12224     default:
12225       break;
12226     }
12227
12228   if (!fn)
12229     return NULL_TREE;
12230
12231   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12232 }
12233
12234 /* Fold a call to the __st[rp]cpy_chk builtin.
12235    DEST, SRC, and SIZE are the arguments to the call.
12236    IGNORE is true if return value can be ignored.  FCODE is the BUILT_IN_*
12237    code of the builtin.  If MAXLEN is not NULL, it is maximum length of
12238    strings passed as second argument.  */
12239
12240 tree
12241 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12242                          tree src, tree size,
12243                          tree maxlen, bool ignore,
12244                          enum built_in_function fcode)
12245 {
12246   tree len, fn;
12247
12248   if (!validate_arg (dest, POINTER_TYPE)
12249       || !validate_arg (src, POINTER_TYPE)
12250       || !validate_arg (size, INTEGER_TYPE))
12251     return NULL_TREE;
12252
12253   /* If SRC and DEST are the same (and not volatile), return DEST.  */
12254   if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12255     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12256
12257   if (! host_integerp (size, 1))
12258     return NULL_TREE;
12259
12260   if (! integer_all_onesp (size))
12261     {
12262       len = c_strlen (src, 1);
12263       if (! len || ! host_integerp (len, 1))
12264         {
12265           /* If LEN is not constant, try MAXLEN too.
12266              For MAXLEN only allow optimizing into non-_ocs function
12267              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12268           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12269             {
12270               if (fcode == BUILT_IN_STPCPY_CHK)
12271                 {
12272                   if (! ignore)
12273                     return NULL_TREE;
12274
12275                   /* If return value of __stpcpy_chk is ignored,
12276                      optimize into __strcpy_chk.  */
12277                   fn = built_in_decls[BUILT_IN_STRCPY_CHK];
12278                   if (!fn)
12279                     return NULL_TREE;
12280
12281                   return build_call_expr_loc (loc, fn, 3, dest, src, size);
12282                 }
12283
12284               if (! len || TREE_SIDE_EFFECTS (len))
12285                 return NULL_TREE;
12286
12287               /* If c_strlen returned something, but not a constant,
12288                  transform __strcpy_chk into __memcpy_chk.  */
12289               fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12290               if (!fn)
12291                 return NULL_TREE;
12292
12293               len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
12294               return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12295                                        build_call_expr_loc (loc, fn, 4,
12296                                                         dest, src, len, size));
12297             }
12298         }
12299       else
12300         maxlen = len;
12301
12302       if (! tree_int_cst_lt (maxlen, size))
12303         return NULL_TREE;
12304     }
12305
12306   /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available.  */
12307   fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
12308                       ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
12309   if (!fn)
12310     return NULL_TREE;
12311
12312   return build_call_expr_loc (loc, fn, 2, dest, src);
12313 }
12314
12315 /* Fold a call to the __strncpy_chk builtin.  DEST, SRC, LEN, and SIZE
12316    are the arguments to the call.  If MAXLEN is not NULL, it is maximum
12317    length passed as third argument.  */
12318
12319 tree
12320 fold_builtin_strncpy_chk (location_t loc, tree dest, tree src,
12321                           tree len, tree size, tree maxlen)
12322 {
12323   tree fn;
12324
12325   if (!validate_arg (dest, POINTER_TYPE)
12326       || !validate_arg (src, POINTER_TYPE)
12327       || !validate_arg (len, INTEGER_TYPE)
12328       || !validate_arg (size, INTEGER_TYPE))
12329     return NULL_TREE;
12330
12331   if (! host_integerp (size, 1))
12332     return NULL_TREE;
12333
12334   if (! integer_all_onesp (size))
12335     {
12336       if (! host_integerp (len, 1))
12337         {
12338           /* If LEN is not constant, try MAXLEN too.
12339              For MAXLEN only allow optimizing into non-_ocs function
12340              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12341           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12342             return NULL_TREE;
12343         }
12344       else
12345         maxlen = len;
12346
12347       if (tree_int_cst_lt (size, maxlen))
12348         return NULL_TREE;
12349     }
12350
12351   /* If __builtin_strncpy_chk is used, assume strncpy is available.  */
12352   fn = built_in_decls[BUILT_IN_STRNCPY];
12353   if (!fn)
12354     return NULL_TREE;
12355
12356   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12357 }
12358
12359 /* Fold a call to the __strcat_chk builtin FNDECL.  DEST, SRC, and SIZE
12360    are the arguments to the call.  */
12361
12362 static tree
12363 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12364                          tree src, tree size)
12365 {
12366   tree fn;
12367   const char *p;
12368
12369   if (!validate_arg (dest, POINTER_TYPE)
12370       || !validate_arg (src, POINTER_TYPE)
12371       || !validate_arg (size, INTEGER_TYPE))
12372     return NULL_TREE;
12373
12374   p = c_getstr (src);
12375   /* If the SRC parameter is "", return DEST.  */
12376   if (p && *p == '\0')
12377     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12378
12379   if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12380     return NULL_TREE;
12381
12382   /* If __builtin_strcat_chk is used, assume strcat is available.  */
12383   fn = built_in_decls[BUILT_IN_STRCAT];
12384   if (!fn)
12385     return NULL_TREE;
12386
12387   return build_call_expr_loc (loc, fn, 2, dest, src);
12388 }
12389
12390 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12391    LEN, and SIZE.  */
12392
12393 static tree
12394 fold_builtin_strncat_chk (location_t loc, tree fndecl,
12395                           tree dest, tree src, tree len, tree size)
12396 {
12397   tree fn;
12398   const char *p;
12399
12400   if (!validate_arg (dest, POINTER_TYPE)
12401       || !validate_arg (src, POINTER_TYPE)
12402       || !validate_arg (size, INTEGER_TYPE)
12403       || !validate_arg (size, INTEGER_TYPE))
12404     return NULL_TREE;
12405
12406   p = c_getstr (src);
12407   /* If the SRC parameter is "" or if LEN is 0, return DEST.  */
12408   if (p && *p == '\0')
12409     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12410   else if (integer_zerop (len))
12411     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12412
12413   if (! host_integerp (size, 1))
12414     return NULL_TREE;
12415
12416   if (! integer_all_onesp (size))
12417     {
12418       tree src_len = c_strlen (src, 1);
12419       if (src_len
12420           && host_integerp (src_len, 1)
12421           && host_integerp (len, 1)
12422           && ! tree_int_cst_lt (len, src_len))
12423         {
12424           /* If LEN >= strlen (SRC), optimize into __strcat_chk.  */
12425           fn = built_in_decls[BUILT_IN_STRCAT_CHK];
12426           if (!fn)
12427             return NULL_TREE;
12428
12429           return build_call_expr_loc (loc, fn, 3, dest, src, size);
12430         }
12431       return NULL_TREE;
12432     }
12433
12434   /* If __builtin_strncat_chk is used, assume strncat is available.  */
12435   fn = built_in_decls[BUILT_IN_STRNCAT];
12436   if (!fn)
12437     return NULL_TREE;
12438
12439   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12440 }
12441
12442 /* Fold a call EXP to __{,v}sprintf_chk.  Return NULL_TREE if
12443    a normal call should be emitted rather than expanding the function
12444    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
12445
12446 static tree
12447 fold_builtin_sprintf_chk (location_t loc, tree exp,
12448                           enum built_in_function fcode)
12449 {
12450   tree dest, size, len, fn, fmt, flag;
12451   const char *fmt_str;
12452   int nargs = call_expr_nargs (exp);
12453
12454   /* Verify the required arguments in the original call.  */
12455   if (nargs < 4)
12456     return NULL_TREE;
12457   dest = CALL_EXPR_ARG (exp, 0);
12458   if (!validate_arg (dest, POINTER_TYPE))
12459     return NULL_TREE;
12460   flag = CALL_EXPR_ARG (exp, 1);
12461   if (!validate_arg (flag, INTEGER_TYPE))
12462     return NULL_TREE;
12463   size = CALL_EXPR_ARG (exp, 2);
12464   if (!validate_arg (size, INTEGER_TYPE))
12465     return NULL_TREE;
12466   fmt = CALL_EXPR_ARG (exp, 3);
12467   if (!validate_arg (fmt, POINTER_TYPE))
12468     return NULL_TREE;
12469
12470   if (! host_integerp (size, 1))
12471     return NULL_TREE;
12472
12473   len = NULL_TREE;
12474
12475   if (!init_target_chars ())
12476     return NULL_TREE;
12477
12478   /* Check whether the format is a literal string constant.  */
12479   fmt_str = c_getstr (fmt);
12480   if (fmt_str != NULL)
12481     {
12482       /* If the format doesn't contain % args or %%, we know the size.  */
12483       if (strchr (fmt_str, target_percent) == 0)
12484         {
12485           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
12486             len = build_int_cstu (size_type_node, strlen (fmt_str));
12487         }
12488       /* If the format is "%s" and first ... argument is a string literal,
12489          we know the size too.  */
12490       else if (fcode == BUILT_IN_SPRINTF_CHK
12491                && strcmp (fmt_str, target_percent_s) == 0)
12492         {
12493           tree arg;
12494
12495           if (nargs == 5)
12496             {
12497               arg = CALL_EXPR_ARG (exp, 4);
12498               if (validate_arg (arg, POINTER_TYPE))
12499                 {
12500                   len = c_strlen (arg, 1);
12501                   if (! len || ! host_integerp (len, 1))
12502                     len = NULL_TREE;
12503                 }
12504             }
12505         }
12506     }
12507
12508   if (! integer_all_onesp (size))
12509     {
12510       if (! len || ! tree_int_cst_lt (len, size))
12511         return NULL_TREE;
12512     }
12513
12514   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12515      or if format doesn't contain % chars or is "%s".  */
12516   if (! integer_zerop (flag))
12517     {
12518       if (fmt_str == NULL)
12519         return NULL_TREE;
12520       if (strchr (fmt_str, target_percent) != NULL
12521           && strcmp (fmt_str, target_percent_s))
12522         return NULL_TREE;
12523     }
12524
12525   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
12526   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
12527                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
12528   if (!fn)
12529     return NULL_TREE;
12530
12531   return rewrite_call_expr (loc, exp, 4, fn, 2, dest, fmt);
12532 }
12533
12534 /* Fold a call EXP to {,v}snprintf.  Return NULL_TREE if
12535    a normal call should be emitted rather than expanding the function
12536    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
12537    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
12538    passed as second argument.  */
12539
12540 tree
12541 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
12542                            enum built_in_function fcode)
12543 {
12544   tree dest, size, len, fn, fmt, flag;
12545   const char *fmt_str;
12546
12547   /* Verify the required arguments in the original call.  */
12548   if (call_expr_nargs (exp) < 5)
12549     return NULL_TREE;
12550   dest = CALL_EXPR_ARG (exp, 0);
12551   if (!validate_arg (dest, POINTER_TYPE))
12552     return NULL_TREE;
12553   len = CALL_EXPR_ARG (exp, 1);
12554   if (!validate_arg (len, INTEGER_TYPE))
12555     return NULL_TREE;
12556   flag = CALL_EXPR_ARG (exp, 2);
12557   if (!validate_arg (flag, INTEGER_TYPE))
12558     return NULL_TREE;
12559   size = CALL_EXPR_ARG (exp, 3);
12560   if (!validate_arg (size, INTEGER_TYPE))
12561     return NULL_TREE;
12562   fmt = CALL_EXPR_ARG (exp, 4);
12563   if (!validate_arg (fmt, POINTER_TYPE))
12564     return NULL_TREE;
12565
12566   if (! host_integerp (size, 1))
12567     return NULL_TREE;
12568
12569   if (! integer_all_onesp (size))
12570     {
12571       if (! host_integerp (len, 1))
12572         {
12573           /* If LEN is not constant, try MAXLEN too.
12574              For MAXLEN only allow optimizing into non-_ocs function
12575              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12576           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12577             return NULL_TREE;
12578         }
12579       else
12580         maxlen = len;
12581
12582       if (tree_int_cst_lt (size, maxlen))
12583         return NULL_TREE;
12584     }
12585
12586   if (!init_target_chars ())
12587     return NULL_TREE;
12588
12589   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12590      or if format doesn't contain % chars or is "%s".  */
12591   if (! integer_zerop (flag))
12592     {
12593       fmt_str = c_getstr (fmt);
12594       if (fmt_str == NULL)
12595         return NULL_TREE;
12596       if (strchr (fmt_str, target_percent) != NULL
12597           && strcmp (fmt_str, target_percent_s))
12598         return NULL_TREE;
12599     }
12600
12601   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12602      available.  */
12603   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
12604                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
12605   if (!fn)
12606     return NULL_TREE;
12607
12608   return rewrite_call_expr (loc, exp, 5, fn, 3, dest, len, fmt);
12609 }
12610
12611 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12612    FMT and ARG are the arguments to the call; we don't fold cases with
12613    more than 2 arguments, and ARG may be null if this is a 1-argument case.
12614
12615    Return NULL_TREE if no simplification was possible, otherwise return the
12616    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12617    code of the function to be simplified.  */
12618
12619 static tree
12620 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
12621                      tree arg, bool ignore,
12622                      enum built_in_function fcode)
12623 {
12624   tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
12625   const char *fmt_str = NULL;
12626
12627   /* If the return value is used, don't do the transformation.  */
12628   if (! ignore)
12629     return NULL_TREE;
12630
12631   /* Verify the required arguments in the original call.  */
12632   if (!validate_arg (fmt, POINTER_TYPE))
12633     return NULL_TREE;
12634
12635   /* Check whether the format is a literal string constant.  */
12636   fmt_str = c_getstr (fmt);
12637   if (fmt_str == NULL)
12638     return NULL_TREE;
12639
12640   if (fcode == BUILT_IN_PRINTF_UNLOCKED)
12641     {
12642       /* If we're using an unlocked function, assume the other
12643          unlocked functions exist explicitly.  */
12644       fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
12645       fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
12646     }
12647   else
12648     {
12649       fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
12650       fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
12651     }
12652
12653   if (!init_target_chars ())
12654     return NULL_TREE;
12655
12656   if (strcmp (fmt_str, target_percent_s) == 0
12657       || strchr (fmt_str, target_percent) == NULL)
12658     {
12659       const char *str;
12660
12661       if (strcmp (fmt_str, target_percent_s) == 0)
12662         {
12663           if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12664             return NULL_TREE;
12665
12666           if (!arg || !validate_arg (arg, POINTER_TYPE))
12667             return NULL_TREE;
12668
12669           str = c_getstr (arg);
12670           if (str == NULL)
12671             return NULL_TREE;
12672         }
12673       else
12674         {
12675           /* The format specifier doesn't contain any '%' characters.  */
12676           if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
12677               && arg)
12678             return NULL_TREE;
12679           str = fmt_str;
12680         }
12681
12682       /* If the string was "", printf does nothing.  */
12683       if (str[0] == '\0')
12684         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12685
12686       /* If the string has length of 1, call putchar.  */
12687       if (str[1] == '\0')
12688         {
12689           /* Given printf("c"), (where c is any one character,)
12690              convert "c"[0] to an int and pass that to the replacement
12691              function.  */
12692           newarg = build_int_cst (NULL_TREE, str[0]);
12693           if (fn_putchar)
12694             call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
12695         }
12696       else
12697         {
12698           /* If the string was "string\n", call puts("string").  */
12699           size_t len = strlen (str);
12700           if ((unsigned char)str[len - 1] == target_newline)
12701             {
12702               /* Create a NUL-terminated string that's one char shorter
12703                  than the original, stripping off the trailing '\n'.  */
12704               char *newstr = XALLOCAVEC (char, len);
12705               memcpy (newstr, str, len - 1);
12706               newstr[len - 1] = 0;
12707
12708               newarg = build_string_literal (len, newstr);
12709               if (fn_puts)
12710                 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
12711             }
12712           else
12713             /* We'd like to arrange to call fputs(string,stdout) here,
12714                but we need stdout and don't have a way to get it yet.  */
12715             return NULL_TREE;
12716         }
12717     }
12718
12719   /* The other optimizations can be done only on the non-va_list variants.  */
12720   else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12721     return NULL_TREE;
12722
12723   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
12724   else if (strcmp (fmt_str, target_percent_s_newline) == 0)
12725     {
12726       if (!arg || !validate_arg (arg, POINTER_TYPE))
12727         return NULL_TREE;
12728       if (fn_puts)
12729         call = build_call_expr_loc (loc, fn_puts, 1, arg);
12730     }
12731
12732   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
12733   else if (strcmp (fmt_str, target_percent_c) == 0)
12734     {
12735       if (!arg || !validate_arg (arg, INTEGER_TYPE))
12736         return NULL_TREE;
12737       if (fn_putchar)
12738         call = build_call_expr_loc (loc, fn_putchar, 1, arg);
12739     }
12740
12741   if (!call)
12742     return NULL_TREE;
12743
12744   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12745 }
12746
12747 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
12748    FP, FMT, and ARG are the arguments to the call.  We don't fold calls with
12749    more than 3 arguments, and ARG may be null in the 2-argument case.
12750
12751    Return NULL_TREE if no simplification was possible, otherwise return the
12752    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12753    code of the function to be simplified.  */
12754
12755 static tree
12756 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
12757                       tree fmt, tree arg, bool ignore,
12758                       enum built_in_function fcode)
12759 {
12760   tree fn_fputc, fn_fputs, call = NULL_TREE;
12761   const char *fmt_str = NULL;
12762
12763   /* If the return value is used, don't do the transformation.  */
12764   if (! ignore)
12765     return NULL_TREE;
12766
12767   /* Verify the required arguments in the original call.  */
12768   if (!validate_arg (fp, POINTER_TYPE))
12769     return NULL_TREE;
12770   if (!validate_arg (fmt, POINTER_TYPE))
12771     return NULL_TREE;
12772
12773   /* Check whether the format is a literal string constant.  */
12774   fmt_str = c_getstr (fmt);
12775   if (fmt_str == NULL)
12776     return NULL_TREE;
12777
12778   if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
12779     {
12780       /* If we're using an unlocked function, assume the other
12781          unlocked functions exist explicitly.  */
12782       fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
12783       fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
12784     }
12785   else
12786     {
12787       fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
12788       fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
12789     }
12790
12791   if (!init_target_chars ())
12792     return NULL_TREE;
12793
12794   /* If the format doesn't contain % args or %%, use strcpy.  */
12795   if (strchr (fmt_str, target_percent) == NULL)
12796     {
12797       if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
12798           && arg)
12799         return NULL_TREE;
12800
12801       /* If the format specifier was "", fprintf does nothing.  */
12802       if (fmt_str[0] == '\0')
12803         {
12804           /* If FP has side-effects, just wait until gimplification is
12805              done.  */
12806           if (TREE_SIDE_EFFECTS (fp))
12807             return NULL_TREE;
12808
12809           return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12810         }
12811
12812       /* When "string" doesn't contain %, replace all cases of
12813          fprintf (fp, string) with fputs (string, fp).  The fputs
12814          builtin will take care of special cases like length == 1.  */
12815       if (fn_fputs)
12816         call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
12817     }
12818
12819   /* The other optimizations can be done only on the non-va_list variants.  */
12820   else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
12821     return NULL_TREE;
12822
12823   /* If the format specifier was "%s", call __builtin_fputs (arg, fp).  */
12824   else if (strcmp (fmt_str, target_percent_s) == 0)
12825     {
12826       if (!arg || !validate_arg (arg, POINTER_TYPE))
12827         return NULL_TREE;
12828       if (fn_fputs)
12829         call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
12830     }
12831
12832   /* If the format specifier was "%c", call __builtin_fputc (arg, fp).  */
12833   else if (strcmp (fmt_str, target_percent_c) == 0)
12834     {
12835       if (!arg || !validate_arg (arg, INTEGER_TYPE))
12836         return NULL_TREE;
12837       if (fn_fputc)
12838         call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
12839     }
12840
12841   if (!call)
12842     return NULL_TREE;
12843   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12844 }
12845
12846 /* Initialize format string characters in the target charset.  */
12847
12848 static bool
12849 init_target_chars (void)
12850 {
12851   static bool init;
12852   if (!init)
12853     {
12854       target_newline = lang_hooks.to_target_charset ('\n');
12855       target_percent = lang_hooks.to_target_charset ('%');
12856       target_c = lang_hooks.to_target_charset ('c');
12857       target_s = lang_hooks.to_target_charset ('s');
12858       if (target_newline == 0 || target_percent == 0 || target_c == 0
12859           || target_s == 0)
12860         return false;
12861
12862       target_percent_c[0] = target_percent;
12863       target_percent_c[1] = target_c;
12864       target_percent_c[2] = '\0';
12865
12866       target_percent_s[0] = target_percent;
12867       target_percent_s[1] = target_s;
12868       target_percent_s[2] = '\0';
12869
12870       target_percent_s_newline[0] = target_percent;
12871       target_percent_s_newline[1] = target_s;
12872       target_percent_s_newline[2] = target_newline;
12873       target_percent_s_newline[3] = '\0';
12874
12875       init = true;
12876     }
12877   return true;
12878 }
12879
12880 /* Helper function for do_mpfr_arg*().  Ensure M is a normal number
12881    and no overflow/underflow occurred.  INEXACT is true if M was not
12882    exactly calculated.  TYPE is the tree type for the result.  This
12883    function assumes that you cleared the MPFR flags and then
12884    calculated M to see if anything subsequently set a flag prior to
12885    entering this function.  Return NULL_TREE if any checks fail.  */
12886
12887 static tree
12888 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
12889 {
12890   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12891      overflow/underflow occurred.  If -frounding-math, proceed iff the
12892      result of calling FUNC was exact.  */
12893   if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
12894       && (!flag_rounding_math || !inexact))
12895     {
12896       REAL_VALUE_TYPE rr;
12897
12898       real_from_mpfr (&rr, m, type, GMP_RNDN);
12899       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
12900          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
12901          but the mpft_t is not, then we underflowed in the
12902          conversion.  */
12903       if (real_isfinite (&rr)
12904           && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
12905         {
12906           REAL_VALUE_TYPE rmode;
12907
12908           real_convert (&rmode, TYPE_MODE (type), &rr);
12909           /* Proceed iff the specified mode can hold the value.  */
12910           if (real_identical (&rmode, &rr))
12911             return build_real (type, rmode);
12912         }
12913     }
12914   return NULL_TREE;
12915 }
12916
12917 /* Helper function for do_mpc_arg*().  Ensure M is a normal complex
12918    number and no overflow/underflow occurred.  INEXACT is true if M
12919    was not exactly calculated.  TYPE is the tree type for the result.
12920    This function assumes that you cleared the MPFR flags and then
12921    calculated M to see if anything subsequently set a flag prior to
12922    entering this function.  Return NULL_TREE if any checks fail, if
12923    FORCE_CONVERT is true, then bypass the checks.  */
12924
12925 static tree
12926 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
12927 {
12928   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12929      overflow/underflow occurred.  If -frounding-math, proceed iff the
12930      result of calling FUNC was exact.  */
12931   if (force_convert
12932       || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
12933           && !mpfr_overflow_p () && !mpfr_underflow_p ()
12934           && (!flag_rounding_math || !inexact)))
12935     {
12936       REAL_VALUE_TYPE re, im;
12937
12938       real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
12939       real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
12940       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
12941          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
12942          but the mpft_t is not, then we underflowed in the
12943          conversion.  */
12944       if (force_convert
12945           || (real_isfinite (&re) && real_isfinite (&im)
12946               && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
12947               && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
12948         {
12949           REAL_VALUE_TYPE re_mode, im_mode;
12950
12951           real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
12952           real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
12953           /* Proceed iff the specified mode can hold the value.  */
12954           if (force_convert
12955               || (real_identical (&re_mode, &re)
12956                   && real_identical (&im_mode, &im)))
12957             return build_complex (type, build_real (TREE_TYPE (type), re_mode),
12958                                   build_real (TREE_TYPE (type), im_mode));
12959         }
12960     }
12961   return NULL_TREE;
12962 }
12963
12964 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
12965    FUNC on it and return the resulting value as a tree with type TYPE.
12966    If MIN and/or MAX are not NULL, then the supplied ARG must be
12967    within those bounds.  If INCLUSIVE is true, then MIN/MAX are
12968    acceptable values, otherwise they are not.  The mpfr precision is
12969    set to the precision of TYPE.  We assume that function FUNC returns
12970    zero if the result could be calculated exactly within the requested
12971    precision.  */
12972
12973 static tree
12974 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
12975               const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
12976               bool inclusive)
12977 {
12978   tree result = NULL_TREE;
12979
12980   STRIP_NOPS (arg);
12981
12982   /* To proceed, MPFR must exactly represent the target floating point
12983      format, which only happens when the target base equals two.  */
12984   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
12985       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
12986     {
12987       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
12988
12989       if (real_isfinite (ra)
12990           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
12991           && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
12992         {
12993           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
12994           const int prec = fmt->p;
12995           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
12996           int inexact;
12997           mpfr_t m;
12998
12999           mpfr_init2 (m, prec);
13000           mpfr_from_real (m, ra, GMP_RNDN);
13001           mpfr_clear_flags ();
13002           inexact = func (m, m, rnd);
13003           result = do_mpfr_ckconv (m, type, inexact);
13004           mpfr_clear (m);
13005         }
13006     }
13007
13008   return result;
13009 }
13010
13011 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13012    FUNC on it and return the resulting value as a tree with type TYPE.
13013    The mpfr precision is set to the precision of TYPE.  We assume that
13014    function FUNC returns zero if the result could be calculated
13015    exactly within the requested precision.  */
13016
13017 static tree
13018 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13019               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13020 {
13021   tree result = NULL_TREE;
13022
13023   STRIP_NOPS (arg1);
13024   STRIP_NOPS (arg2);
13025
13026   /* To proceed, MPFR must exactly represent the target floating point
13027      format, which only happens when the target base equals two.  */
13028   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13029       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13030       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13031     {
13032       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13033       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13034
13035       if (real_isfinite (ra1) && real_isfinite (ra2))
13036         {
13037           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13038           const int prec = fmt->p;
13039           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13040           int inexact;
13041           mpfr_t m1, m2;
13042
13043           mpfr_inits2 (prec, m1, m2, NULL);
13044           mpfr_from_real (m1, ra1, GMP_RNDN);
13045           mpfr_from_real (m2, ra2, GMP_RNDN);
13046           mpfr_clear_flags ();
13047           inexact = func (m1, m1, m2, rnd);
13048           result = do_mpfr_ckconv (m1, type, inexact);
13049           mpfr_clears (m1, m2, NULL);
13050         }
13051     }
13052
13053   return result;
13054 }
13055
13056 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13057    FUNC on it and return the resulting value as a tree with type TYPE.
13058    The mpfr precision is set to the precision of TYPE.  We assume that
13059    function FUNC returns zero if the result could be calculated
13060    exactly within the requested precision.  */
13061
13062 static tree
13063 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13064               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13065 {
13066   tree result = NULL_TREE;
13067
13068   STRIP_NOPS (arg1);
13069   STRIP_NOPS (arg2);
13070   STRIP_NOPS (arg3);
13071
13072   /* To proceed, MPFR must exactly represent the target floating point
13073      format, which only happens when the target base equals two.  */
13074   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13075       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13076       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13077       && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13078     {
13079       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13080       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13081       const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13082
13083       if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13084         {
13085           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13086           const int prec = fmt->p;
13087           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13088           int inexact;
13089           mpfr_t m1, m2, m3;
13090
13091           mpfr_inits2 (prec, m1, m2, m3, NULL);
13092           mpfr_from_real (m1, ra1, GMP_RNDN);
13093           mpfr_from_real (m2, ra2, GMP_RNDN);
13094           mpfr_from_real (m3, ra3, GMP_RNDN);
13095           mpfr_clear_flags ();
13096           inexact = func (m1, m1, m2, m3, rnd);
13097           result = do_mpfr_ckconv (m1, type, inexact);
13098           mpfr_clears (m1, m2, m3, NULL);
13099         }
13100     }
13101
13102   return result;
13103 }
13104
13105 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13106    the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13107    If ARG_SINP and ARG_COSP are NULL then the result is returned
13108    as a complex value.
13109    The type is taken from the type of ARG and is used for setting the
13110    precision of the calculation and results.  */
13111
13112 static tree
13113 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13114 {
13115   tree const type = TREE_TYPE (arg);
13116   tree result = NULL_TREE;
13117
13118   STRIP_NOPS (arg);
13119
13120   /* To proceed, MPFR must exactly represent the target floating point
13121      format, which only happens when the target base equals two.  */
13122   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13123       && TREE_CODE (arg) == REAL_CST
13124       && !TREE_OVERFLOW (arg))
13125     {
13126       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13127
13128       if (real_isfinite (ra))
13129         {
13130           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13131           const int prec = fmt->p;
13132           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13133           tree result_s, result_c;
13134           int inexact;
13135           mpfr_t m, ms, mc;
13136
13137           mpfr_inits2 (prec, m, ms, mc, NULL);
13138           mpfr_from_real (m, ra, GMP_RNDN);
13139           mpfr_clear_flags ();
13140           inexact = mpfr_sin_cos (ms, mc, m, rnd);
13141           result_s = do_mpfr_ckconv (ms, type, inexact);
13142           result_c = do_mpfr_ckconv (mc, type, inexact);
13143           mpfr_clears (m, ms, mc, NULL);
13144           if (result_s && result_c)
13145             {
13146               /* If we are to return in a complex value do so.  */
13147               if (!arg_sinp && !arg_cosp)
13148                 return build_complex (build_complex_type (type),
13149                                       result_c, result_s);
13150
13151               /* Dereference the sin/cos pointer arguments.  */
13152               arg_sinp = build_fold_indirect_ref (arg_sinp);
13153               arg_cosp = build_fold_indirect_ref (arg_cosp);
13154               /* Proceed if valid pointer type were passed in.  */
13155               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13156                   && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13157                 {
13158                   /* Set the values. */
13159                   result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13160                                           result_s);
13161                   TREE_SIDE_EFFECTS (result_s) = 1;
13162                   result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13163                                           result_c);
13164                   TREE_SIDE_EFFECTS (result_c) = 1;
13165                   /* Combine the assignments into a compound expr.  */
13166                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13167                                                     result_s, result_c));
13168                 }
13169             }
13170         }
13171     }
13172   return result;
13173 }
13174
13175 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13176    two-argument mpfr order N Bessel function FUNC on them and return
13177    the resulting value as a tree with type TYPE.  The mpfr precision
13178    is set to the precision of TYPE.  We assume that function FUNC
13179    returns zero if the result could be calculated exactly within the
13180    requested precision.  */
13181 static tree
13182 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13183                   int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13184                   const REAL_VALUE_TYPE *min, bool inclusive)
13185 {
13186   tree result = NULL_TREE;
13187
13188   STRIP_NOPS (arg1);
13189   STRIP_NOPS (arg2);
13190
13191   /* To proceed, MPFR must exactly represent the target floating point
13192      format, which only happens when the target base equals two.  */
13193   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13194       && host_integerp (arg1, 0)
13195       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13196     {
13197       const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13198       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13199
13200       if (n == (long)n
13201           && real_isfinite (ra)
13202           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13203         {
13204           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13205           const int prec = fmt->p;
13206           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13207           int inexact;
13208           mpfr_t m;
13209
13210           mpfr_init2 (m, prec);
13211           mpfr_from_real (m, ra, GMP_RNDN);
13212           mpfr_clear_flags ();
13213           inexact = func (m, n, m, rnd);
13214           result = do_mpfr_ckconv (m, type, inexact);
13215           mpfr_clear (m);
13216         }
13217     }
13218
13219   return result;
13220 }
13221
13222 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13223    the pointer *(ARG_QUO) and return the result.  The type is taken
13224    from the type of ARG0 and is used for setting the precision of the
13225    calculation and results.  */
13226
13227 static tree
13228 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13229 {
13230   tree const type = TREE_TYPE (arg0);
13231   tree result = NULL_TREE;
13232
13233   STRIP_NOPS (arg0);
13234   STRIP_NOPS (arg1);
13235
13236   /* To proceed, MPFR must exactly represent the target floating point
13237      format, which only happens when the target base equals two.  */
13238   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13239       && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13240       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13241     {
13242       const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13243       const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13244
13245       if (real_isfinite (ra0) && real_isfinite (ra1))
13246         {
13247           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13248           const int prec = fmt->p;
13249           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13250           tree result_rem;
13251           long integer_quo;
13252           mpfr_t m0, m1;
13253
13254           mpfr_inits2 (prec, m0, m1, NULL);
13255           mpfr_from_real (m0, ra0, GMP_RNDN);
13256           mpfr_from_real (m1, ra1, GMP_RNDN);
13257           mpfr_clear_flags ();
13258           mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13259           /* Remquo is independent of the rounding mode, so pass
13260              inexact=0 to do_mpfr_ckconv().  */
13261           result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13262           mpfr_clears (m0, m1, NULL);
13263           if (result_rem)
13264             {
13265               /* MPFR calculates quo in the host's long so it may
13266                  return more bits in quo than the target int can hold
13267                  if sizeof(host long) > sizeof(target int).  This can
13268                  happen even for native compilers in LP64 mode.  In
13269                  these cases, modulo the quo value with the largest
13270                  number that the target int can hold while leaving one
13271                  bit for the sign.  */
13272               if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13273                 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13274
13275               /* Dereference the quo pointer argument.  */
13276               arg_quo = build_fold_indirect_ref (arg_quo);
13277               /* Proceed iff a valid pointer type was passed in.  */
13278               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13279                 {
13280                   /* Set the value. */
13281                   tree result_quo = fold_build2 (MODIFY_EXPR,
13282                                                  TREE_TYPE (arg_quo), arg_quo,
13283                                                  build_int_cst (NULL, integer_quo));
13284                   TREE_SIDE_EFFECTS (result_quo) = 1;
13285                   /* Combine the quo assignment with the rem.  */
13286                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13287                                                     result_quo, result_rem));
13288                 }
13289             }
13290         }
13291     }
13292   return result;
13293 }
13294
13295 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13296    resulting value as a tree with type TYPE.  The mpfr precision is
13297    set to the precision of TYPE.  We assume that this mpfr function
13298    returns zero if the result could be calculated exactly within the
13299    requested precision.  In addition, the integer pointer represented
13300    by ARG_SG will be dereferenced and set to the appropriate signgam
13301    (-1,1) value.  */
13302
13303 static tree
13304 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13305 {
13306   tree result = NULL_TREE;
13307
13308   STRIP_NOPS (arg);
13309
13310   /* To proceed, MPFR must exactly represent the target floating point
13311      format, which only happens when the target base equals two.  Also
13312      verify ARG is a constant and that ARG_SG is an int pointer.  */
13313   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13314       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13315       && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13316       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13317     {
13318       const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13319
13320       /* In addition to NaN and Inf, the argument cannot be zero or a
13321          negative integer.  */
13322       if (real_isfinite (ra)
13323           && ra->cl != rvc_zero
13324           && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13325         {
13326           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13327           const int prec = fmt->p;
13328           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13329           int inexact, sg;
13330           mpfr_t m;
13331           tree result_lg;
13332
13333           mpfr_init2 (m, prec);
13334           mpfr_from_real (m, ra, GMP_RNDN);
13335           mpfr_clear_flags ();
13336           inexact = mpfr_lgamma (m, &sg, m, rnd);
13337           result_lg = do_mpfr_ckconv (m, type, inexact);
13338           mpfr_clear (m);
13339           if (result_lg)
13340             {
13341               tree result_sg;
13342
13343               /* Dereference the arg_sg pointer argument.  */
13344               arg_sg = build_fold_indirect_ref (arg_sg);
13345               /* Assign the signgam value into *arg_sg. */
13346               result_sg = fold_build2 (MODIFY_EXPR,
13347                                        TREE_TYPE (arg_sg), arg_sg,
13348                                        build_int_cst (NULL, sg));
13349               TREE_SIDE_EFFECTS (result_sg) = 1;
13350               /* Combine the signgam assignment with the lgamma result.  */
13351               result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13352                                                 result_sg, result_lg));
13353             }
13354         }
13355     }
13356
13357   return result;
13358 }
13359
13360 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13361    function FUNC on it and return the resulting value as a tree with
13362    type TYPE.  The mpfr precision is set to the precision of TYPE.  We
13363    assume that function FUNC returns zero if the result could be
13364    calculated exactly within the requested precision.  */
13365
13366 static tree
13367 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13368 {
13369   tree result = NULL_TREE;
13370
13371   STRIP_NOPS (arg);
13372
13373   /* To proceed, MPFR must exactly represent the target floating point
13374      format, which only happens when the target base equals two.  */
13375   if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
13376       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
13377       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
13378     {
13379       const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
13380       const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
13381
13382       if (real_isfinite (re) && real_isfinite (im))
13383         {
13384           const struct real_format *const fmt =
13385             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13386           const int prec = fmt->p;
13387           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13388           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13389           int inexact;
13390           mpc_t m;
13391
13392           mpc_init2 (m, prec);
13393           mpfr_from_real (mpc_realref(m), re, rnd);
13394           mpfr_from_real (mpc_imagref(m), im, rnd);
13395           mpfr_clear_flags ();
13396           inexact = func (m, m, crnd);
13397           result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
13398           mpc_clear (m);
13399         }
13400     }
13401
13402   return result;
13403 }
13404
13405 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
13406    mpc function FUNC on it and return the resulting value as a tree
13407    with type TYPE.  The mpfr precision is set to the precision of
13408    TYPE.  We assume that function FUNC returns zero if the result
13409    could be calculated exactly within the requested precision.  If
13410    DO_NONFINITE is true, then fold expressions containing Inf or NaN
13411    in the arguments and/or results.  */
13412
13413 tree
13414 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
13415              int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
13416 {
13417   tree result = NULL_TREE;
13418
13419   STRIP_NOPS (arg0);
13420   STRIP_NOPS (arg1);
13421
13422   /* To proceed, MPFR must exactly represent the target floating point
13423      format, which only happens when the target base equals two.  */
13424   if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
13425       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
13426       && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
13427       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
13428       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
13429     {
13430       const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
13431       const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
13432       const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
13433       const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
13434
13435       if (do_nonfinite
13436           || (real_isfinite (re0) && real_isfinite (im0)
13437               && real_isfinite (re1) && real_isfinite (im1)))
13438         {
13439           const struct real_format *const fmt =
13440             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13441           const int prec = fmt->p;
13442           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13443           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13444           int inexact;
13445           mpc_t m0, m1;
13446
13447           mpc_init2 (m0, prec);
13448           mpc_init2 (m1, prec);
13449           mpfr_from_real (mpc_realref(m0), re0, rnd);
13450           mpfr_from_real (mpc_imagref(m0), im0, rnd);
13451           mpfr_from_real (mpc_realref(m1), re1, rnd);
13452           mpfr_from_real (mpc_imagref(m1), im1, rnd);
13453           mpfr_clear_flags ();
13454           inexact = func (m0, m0, m1, crnd);
13455           result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
13456           mpc_clear (m0);
13457           mpc_clear (m1);
13458         }
13459     }
13460
13461   return result;
13462 }
13463
13464 /* FIXME tuples.
13465    The functions below provide an alternate interface for folding
13466    builtin function calls presented as GIMPLE_CALL statements rather
13467    than as CALL_EXPRs.  The folded result is still expressed as a
13468    tree.  There is too much code duplication in the handling of
13469    varargs functions, and a more intrusive re-factoring would permit
13470    better sharing of code between the tree and statement-based
13471    versions of these functions.  */
13472
13473 /* Construct a new CALL_EXPR using the tail of the argument list of STMT
13474    along with N new arguments specified as the "..." parameters.  SKIP
13475    is the number of arguments in STMT to be omitted.  This function is used
13476    to do varargs-to-varargs transformations.  */
13477
13478 static tree
13479 gimple_rewrite_call_expr (gimple stmt, int skip, tree fndecl, int n, ...)
13480 {
13481   int oldnargs = gimple_call_num_args (stmt);
13482   int nargs = oldnargs - skip + n;
13483   tree fntype = TREE_TYPE (fndecl);
13484   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
13485   tree *buffer;
13486   int i, j;
13487   va_list ap;
13488   location_t loc = gimple_location (stmt);
13489
13490   buffer = XALLOCAVEC (tree, nargs);
13491   va_start (ap, n);
13492   for (i = 0; i < n; i++)
13493     buffer[i] = va_arg (ap, tree);
13494   va_end (ap);
13495   for (j = skip; j < oldnargs; j++, i++)
13496     buffer[i] = gimple_call_arg (stmt, j);
13497
13498   return fold (build_call_array_loc (loc, TREE_TYPE (fntype), fn, nargs, buffer));
13499 }
13500
13501 /* Fold a call STMT to __{,v}sprintf_chk.  Return NULL_TREE if
13502    a normal call should be emitted rather than expanding the function
13503    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
13504
13505 static tree
13506 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
13507 {
13508   tree dest, size, len, fn, fmt, flag;
13509   const char *fmt_str;
13510   int nargs = gimple_call_num_args (stmt);
13511
13512   /* Verify the required arguments in the original call.  */
13513   if (nargs < 4)
13514     return NULL_TREE;
13515   dest = gimple_call_arg (stmt, 0);
13516   if (!validate_arg (dest, POINTER_TYPE))
13517     return NULL_TREE;
13518   flag = gimple_call_arg (stmt, 1);
13519   if (!validate_arg (flag, INTEGER_TYPE))
13520     return NULL_TREE;
13521   size = gimple_call_arg (stmt, 2);
13522   if (!validate_arg (size, INTEGER_TYPE))
13523     return NULL_TREE;
13524   fmt = gimple_call_arg (stmt, 3);
13525   if (!validate_arg (fmt, POINTER_TYPE))
13526     return NULL_TREE;
13527
13528   if (! host_integerp (size, 1))
13529     return NULL_TREE;
13530
13531   len = NULL_TREE;
13532
13533   if (!init_target_chars ())
13534     return NULL_TREE;
13535
13536   /* Check whether the format is a literal string constant.  */
13537   fmt_str = c_getstr (fmt);
13538   if (fmt_str != NULL)
13539     {
13540       /* If the format doesn't contain % args or %%, we know the size.  */
13541       if (strchr (fmt_str, target_percent) == 0)
13542         {
13543           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
13544             len = build_int_cstu (size_type_node, strlen (fmt_str));
13545         }
13546       /* If the format is "%s" and first ... argument is a string literal,
13547          we know the size too.  */
13548       else if (fcode == BUILT_IN_SPRINTF_CHK
13549                && strcmp (fmt_str, target_percent_s) == 0)
13550         {
13551           tree arg;
13552
13553           if (nargs == 5)
13554             {
13555               arg = gimple_call_arg (stmt, 4);
13556               if (validate_arg (arg, POINTER_TYPE))
13557                 {
13558                   len = c_strlen (arg, 1);
13559                   if (! len || ! host_integerp (len, 1))
13560                     len = NULL_TREE;
13561                 }
13562             }
13563         }
13564     }
13565
13566   if (! integer_all_onesp (size))
13567     {
13568       if (! len || ! tree_int_cst_lt (len, size))
13569         return NULL_TREE;
13570     }
13571
13572   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13573      or if format doesn't contain % chars or is "%s".  */
13574   if (! integer_zerop (flag))
13575     {
13576       if (fmt_str == NULL)
13577         return NULL_TREE;
13578       if (strchr (fmt_str, target_percent) != NULL
13579           && strcmp (fmt_str, target_percent_s))
13580         return NULL_TREE;
13581     }
13582
13583   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
13584   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
13585                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
13586   if (!fn)
13587     return NULL_TREE;
13588
13589   return gimple_rewrite_call_expr (stmt, 4, fn, 2, dest, fmt);
13590 }
13591
13592 /* Fold a call STMT to {,v}snprintf.  Return NULL_TREE if
13593    a normal call should be emitted rather than expanding the function
13594    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
13595    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
13596    passed as second argument.  */
13597
13598 tree
13599 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
13600                                   enum built_in_function fcode)
13601 {
13602   tree dest, size, len, fn, fmt, flag;
13603   const char *fmt_str;
13604
13605   /* Verify the required arguments in the original call.  */
13606   if (gimple_call_num_args (stmt) < 5)
13607     return NULL_TREE;
13608   dest = gimple_call_arg (stmt, 0);
13609   if (!validate_arg (dest, POINTER_TYPE))
13610     return NULL_TREE;
13611   len = gimple_call_arg (stmt, 1);
13612   if (!validate_arg (len, INTEGER_TYPE))
13613     return NULL_TREE;
13614   flag = gimple_call_arg (stmt, 2);
13615   if (!validate_arg (flag, INTEGER_TYPE))
13616     return NULL_TREE;
13617   size = gimple_call_arg (stmt, 3);
13618   if (!validate_arg (size, INTEGER_TYPE))
13619     return NULL_TREE;
13620   fmt = gimple_call_arg (stmt, 4);
13621   if (!validate_arg (fmt, POINTER_TYPE))
13622     return NULL_TREE;
13623
13624   if (! host_integerp (size, 1))
13625     return NULL_TREE;
13626
13627   if (! integer_all_onesp (size))
13628     {
13629       if (! host_integerp (len, 1))
13630         {
13631           /* If LEN is not constant, try MAXLEN too.
13632              For MAXLEN only allow optimizing into non-_ocs function
13633              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
13634           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
13635             return NULL_TREE;
13636         }
13637       else
13638         maxlen = len;
13639
13640       if (tree_int_cst_lt (size, maxlen))
13641         return NULL_TREE;
13642     }
13643
13644   if (!init_target_chars ())
13645     return NULL_TREE;
13646
13647   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13648      or if format doesn't contain % chars or is "%s".  */
13649   if (! integer_zerop (flag))
13650     {
13651       fmt_str = c_getstr (fmt);
13652       if (fmt_str == NULL)
13653         return NULL_TREE;
13654       if (strchr (fmt_str, target_percent) != NULL
13655           && strcmp (fmt_str, target_percent_s))
13656         return NULL_TREE;
13657     }
13658
13659   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13660      available.  */
13661   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
13662                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
13663   if (!fn)
13664     return NULL_TREE;
13665
13666   return gimple_rewrite_call_expr (stmt, 5, fn, 3, dest, len, fmt);
13667 }
13668
13669 /* Builtins with folding operations that operate on "..." arguments
13670    need special handling; we need to store the arguments in a convenient
13671    data structure before attempting any folding.  Fortunately there are
13672    only a few builtins that fall into this category.  FNDECL is the
13673    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13674    result of the function call is ignored.  */
13675
13676 static tree
13677 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
13678                              bool ignore ATTRIBUTE_UNUSED)
13679 {
13680   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13681   tree ret = NULL_TREE;
13682
13683   switch (fcode)
13684     {
13685     case BUILT_IN_SPRINTF_CHK:
13686     case BUILT_IN_VSPRINTF_CHK:
13687       ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
13688       break;
13689
13690     case BUILT_IN_SNPRINTF_CHK:
13691     case BUILT_IN_VSNPRINTF_CHK:
13692       ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
13693
13694     default:
13695       break;
13696     }
13697   if (ret)
13698     {
13699       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
13700       TREE_NO_WARNING (ret) = 1;
13701       return ret;
13702     }
13703   return NULL_TREE;
13704 }
13705
13706 /* A wrapper function for builtin folding that prevents warnings for
13707    "statement without effect" and the like, caused by removing the
13708    call node earlier than the warning is generated.  */
13709
13710 tree
13711 fold_call_stmt (gimple stmt, bool ignore)
13712 {
13713   tree ret = NULL_TREE;
13714   tree fndecl = gimple_call_fndecl (stmt);
13715   location_t loc = gimple_location (stmt);
13716   if (fndecl
13717       && TREE_CODE (fndecl) == FUNCTION_DECL
13718       && DECL_BUILT_IN (fndecl)
13719       && !gimple_call_va_arg_pack_p (stmt))
13720     {
13721       int nargs = gimple_call_num_args (stmt);
13722
13723       if (avoid_folding_inline_builtin (fndecl))
13724         return NULL_TREE;
13725       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
13726         {
13727           return targetm.fold_builtin (fndecl, nargs,
13728                                        (nargs > 0
13729                                         ? gimple_call_arg_ptr (stmt, 0)
13730                                         : &error_mark_node), ignore);
13731         }
13732       else
13733         {
13734           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
13735             {
13736               tree args[MAX_ARGS_TO_FOLD_BUILTIN];
13737               int i;
13738               for (i = 0; i < nargs; i++)
13739                 args[i] = gimple_call_arg (stmt, i);
13740               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
13741             }
13742           if (!ret)
13743             ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
13744           if (ret)
13745             {
13746               /* Propagate location information from original call to
13747                  expansion of builtin.  Otherwise things like
13748                  maybe_emit_chk_warning, that operate on the expansion
13749                  of a builtin, will use the wrong location information.  */
13750               if (gimple_has_location (stmt))
13751                 {
13752                   tree realret = ret;
13753                   if (TREE_CODE (ret) == NOP_EXPR)
13754                     realret = TREE_OPERAND (ret, 0);
13755                   if (CAN_HAVE_LOCATION_P (realret)
13756                       && !EXPR_HAS_LOCATION (realret))
13757                     SET_EXPR_LOCATION (realret, loc);
13758                   return realret;
13759                 }
13760               return ret;
13761             }
13762         }
13763     }
13764   return NULL_TREE;
13765 }
13766
13767 /* Look up the function in built_in_decls that corresponds to DECL
13768    and set ASMSPEC as its user assembler name.  DECL must be a
13769    function decl that declares a builtin.  */
13770
13771 void
13772 set_builtin_user_assembler_name (tree decl, const char *asmspec)
13773 {
13774   tree builtin;
13775   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
13776               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
13777               && asmspec != 0);
13778
13779   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
13780   set_user_assembler_name (builtin, asmspec);
13781   switch (DECL_FUNCTION_CODE (decl))
13782     {
13783     case BUILT_IN_MEMCPY:
13784       init_block_move_fn (asmspec);
13785       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
13786       break;
13787     case BUILT_IN_MEMSET:
13788       init_block_clear_fn (asmspec);
13789       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
13790       break;
13791     case BUILT_IN_MEMMOVE:
13792       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
13793       break;
13794     case BUILT_IN_MEMCMP:
13795       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
13796       break;
13797     case BUILT_IN_ABORT:
13798       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
13799       break;
13800     case BUILT_IN_FFS:
13801       if (INT_TYPE_SIZE < BITS_PER_WORD)
13802         {
13803           set_user_assembler_libfunc ("ffs", asmspec);
13804           set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
13805                                                        MODE_INT, 0), "ffs");
13806         }
13807       break;
13808     default:
13809       break;
13810     }
13811 }
13812
13813 /* Return true if DECL is a builtin that expands to a constant or similarly
13814    simple code.  */
13815 bool
13816 is_simple_builtin (tree decl)
13817 {
13818   if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13819     switch (DECL_FUNCTION_CODE (decl))
13820       {
13821         /* Builtins that expand to constants.  */
13822       case BUILT_IN_CONSTANT_P:
13823       case BUILT_IN_EXPECT:
13824       case BUILT_IN_OBJECT_SIZE:
13825       case BUILT_IN_UNREACHABLE:
13826         /* Simple register moves or loads from stack.  */
13827       case BUILT_IN_RETURN_ADDRESS:
13828       case BUILT_IN_EXTRACT_RETURN_ADDR:
13829       case BUILT_IN_FROB_RETURN_ADDR:
13830       case BUILT_IN_RETURN:
13831       case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
13832       case BUILT_IN_FRAME_ADDRESS:
13833       case BUILT_IN_VA_END:
13834       case BUILT_IN_STACK_SAVE:
13835       case BUILT_IN_STACK_RESTORE:
13836         /* Exception state returns or moves registers around.  */
13837       case BUILT_IN_EH_FILTER:
13838       case BUILT_IN_EH_POINTER:
13839       case BUILT_IN_EH_COPY_VALUES:
13840         return true;
13841
13842       default:
13843         return false;
13844       }
13845
13846   return false;
13847 }
13848
13849 /* Return true if DECL is a builtin that is not expensive, i.e., they are
13850    most probably expanded inline into reasonably simple code.  This is a
13851    superset of is_simple_builtin.  */
13852 bool
13853 is_inexpensive_builtin (tree decl)
13854 {
13855   if (!decl)
13856     return false;
13857   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
13858     return true;
13859   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13860     switch (DECL_FUNCTION_CODE (decl))
13861       {
13862       case BUILT_IN_ABS:
13863       case BUILT_IN_ALLOCA:
13864       case BUILT_IN_BSWAP32:
13865       case BUILT_IN_BSWAP64:
13866       case BUILT_IN_CLZ:
13867       case BUILT_IN_CLZIMAX:
13868       case BUILT_IN_CLZL:
13869       case BUILT_IN_CLZLL:
13870       case BUILT_IN_CTZ:
13871       case BUILT_IN_CTZIMAX:
13872       case BUILT_IN_CTZL:
13873       case BUILT_IN_CTZLL:
13874       case BUILT_IN_FFS:
13875       case BUILT_IN_FFSIMAX:
13876       case BUILT_IN_FFSL:
13877       case BUILT_IN_FFSLL:
13878       case BUILT_IN_IMAXABS:
13879       case BUILT_IN_FINITE:
13880       case BUILT_IN_FINITEF:
13881       case BUILT_IN_FINITEL:
13882       case BUILT_IN_FINITED32:
13883       case BUILT_IN_FINITED64:
13884       case BUILT_IN_FINITED128:
13885       case BUILT_IN_FPCLASSIFY:
13886       case BUILT_IN_ISFINITE:
13887       case BUILT_IN_ISINF_SIGN:
13888       case BUILT_IN_ISINF:
13889       case BUILT_IN_ISINFF:
13890       case BUILT_IN_ISINFL:
13891       case BUILT_IN_ISINFD32:
13892       case BUILT_IN_ISINFD64:
13893       case BUILT_IN_ISINFD128:
13894       case BUILT_IN_ISNAN:
13895       case BUILT_IN_ISNANF:
13896       case BUILT_IN_ISNANL:
13897       case BUILT_IN_ISNAND32:
13898       case BUILT_IN_ISNAND64:
13899       case BUILT_IN_ISNAND128:
13900       case BUILT_IN_ISNORMAL:
13901       case BUILT_IN_ISGREATER:
13902       case BUILT_IN_ISGREATEREQUAL:
13903       case BUILT_IN_ISLESS:
13904       case BUILT_IN_ISLESSEQUAL:
13905       case BUILT_IN_ISLESSGREATER:
13906       case BUILT_IN_ISUNORDERED:
13907       case BUILT_IN_VA_ARG_PACK:
13908       case BUILT_IN_VA_ARG_PACK_LEN:
13909       case BUILT_IN_VA_COPY:
13910       case BUILT_IN_TRAP:
13911       case BUILT_IN_SAVEREGS:
13912       case BUILT_IN_POPCOUNTL:
13913       case BUILT_IN_POPCOUNTLL:
13914       case BUILT_IN_POPCOUNTIMAX:
13915       case BUILT_IN_POPCOUNT:
13916       case BUILT_IN_PARITYL:
13917       case BUILT_IN_PARITYLL:
13918       case BUILT_IN_PARITYIMAX:
13919       case BUILT_IN_PARITY:
13920       case BUILT_IN_LABS:
13921       case BUILT_IN_LLABS:
13922       case BUILT_IN_PREFETCH:
13923         return true;
13924
13925       default:
13926         return is_simple_builtin (decl);
13927       }
13928
13929   return false;
13930 }
13931