gcc/builtins.c

   1 /* Expand builtin functions.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "machmode.h"
  27 #include "rtl.h"
  28 #include "tree.h"
  29 #include "realmpfr.h"
  30 #include "gimple.h"
  31 #include "flags.h"
  32 #include "regs.h"
  33 #include "hard-reg-set.h"
  34 #include "except.h"
  35 #include "function.h"
  36 #include "insn-config.h"
  37 #include "expr.h"
  38 #include "optabs.h"
  39 #include "libfuncs.h"
  40 #include "recog.h"
  41 #include "output.h"
  42 #include "typeclass.h"
  43 #include "toplev.h"
  44 #include "predict.h"
  45 #include "tm_p.h"
  46 #include "target.h"
  47 #include "langhooks.h"
  48 #include "basic-block.h"
  49 #include "tree-mudflap.h"
  50 #include "tree-flow.h"
  51 #include "value-prof.h"
  52 #include "diagnostic-core.h"
  53 #include "builtins.h"
  54
  55 #ifndef SLOW_UNALIGNED_ACCESS
  56 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
  57 #endif
  58
  59 #ifndef PAD_VARARGS_DOWN
  60 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
  61 #endif
  62 static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));
  63
  64 struct target_builtins default_target_builtins;
  65 #if SWITCHABLE_TARGET
  66 struct target_builtins *this_target_builtins = &default_target_builtins;
  67 #endif
  68
  69 /* Define the names of the builtin function types and codes.  */
  70 const char *const built_in_class_names[4]
  71   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
  72
  73 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
  74 const char * built_in_names[(int) END_BUILTINS] =
  75 {
  76 #include "builtins.def"
  77 };
  78 #undef DEF_BUILTIN
  79
  80 /* Setup an array of _DECL trees, make sure each element is
  81    initialized to NULL_TREE.  */
  82 tree built_in_decls[(int) END_BUILTINS];
  83 /* Declarations used when constructing the builtin implicitly in the compiler.
  84    It may be NULL_TREE when this is invalid (for instance runtime is not
  85    required to implement the function call in all cases).  */
  86 tree implicit_built_in_decls[(int) END_BUILTINS];
  87
  88 static const char *c_getstr (tree);
  89 static rtx c_readstr (const char *, enum machine_mode);
  90 static int target_char_cast (tree, char *);
  91 static rtx get_memory_rtx (tree, tree);
  92 static int apply_args_size (void);
  93 static int apply_result_size (void);
  94 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
  95 static rtx result_vector (int, rtx);
  96 #endif
  97 static void expand_builtin_update_setjmp_buf (rtx);
  98 static void expand_builtin_prefetch (tree);
  99 static rtx expand_builtin_apply_args (void);
 100 static rtx expand_builtin_apply_args_1 (void);
 101 static rtx expand_builtin_apply (rtx, rtx, rtx);
 102 static void expand_builtin_return (rtx);
 103 static enum type_class type_to_class (tree);
 104 static rtx expand_builtin_classify_type (tree);
 105 static void expand_errno_check (tree, rtx);
 106 static rtx expand_builtin_mathfn (tree, rtx, rtx);
 107 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
 108 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
 109 static rtx expand_builtin_interclass_mathfn (tree, rtx, rtx);
 110 static rtx expand_builtin_sincos (tree);
 111 static rtx expand_builtin_cexpi (tree, rtx, rtx);
 112 static rtx expand_builtin_int_roundingfn (tree, rtx);
 113 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
 114 static rtx expand_builtin_next_arg (void);
 115 static rtx expand_builtin_va_start (tree);
 116 static rtx expand_builtin_va_end (tree);
 117 static rtx expand_builtin_va_copy (tree);
 118 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
 119 static rtx expand_builtin_strcmp (tree, rtx);
 120 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
 121 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 122 static rtx expand_builtin_memcpy (tree, rtx);
 123 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
 124 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
 125                                         enum machine_mode, int);
 126 static rtx expand_builtin_strcpy (tree, rtx);
 127 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
 128 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
 129 static rtx expand_builtin_strncpy (tree, rtx);
 130 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
 131 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
 132 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
 133 static rtx expand_builtin_bzero (tree);
 134 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
 135 static rtx expand_builtin_alloca (tree, rtx, bool);
 136 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
 137 static rtx expand_builtin_frame_address (tree, tree);
 138 static tree stabilize_va_list_loc (location_t, tree, int);
 139 static rtx expand_builtin_expect (tree, rtx);
 140 static tree fold_builtin_constant_p (tree);
 141 static tree fold_builtin_expect (location_t, tree, tree);
 142 static tree fold_builtin_classify_type (tree);
 143 static tree fold_builtin_strlen (location_t, tree, tree);
 144 static tree fold_builtin_inf (location_t, tree, int);
 145 static tree fold_builtin_nan (tree, tree, int);
 146 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
 147 static bool validate_arg (const_tree, enum tree_code code);
 148 static bool integer_valued_real_p (tree);
 149 static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
 150 static bool readonly_data_expr (tree);
 151 static rtx expand_builtin_fabs (tree, rtx, rtx);
 152 static rtx expand_builtin_signbit (tree, rtx);
 153 static tree fold_builtin_sqrt (location_t, tree, tree);
 154 static tree fold_builtin_cbrt (location_t, tree, tree);
 155 static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
 156 static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
 157 static tree fold_builtin_cos (location_t, tree, tree, tree);
 158 static tree fold_builtin_cosh (location_t, tree, tree, tree);
 159 static tree fold_builtin_tan (tree, tree);
 160 static tree fold_builtin_trunc (location_t, tree, tree);
 161 static tree fold_builtin_floor (location_t, tree, tree);
 162 static tree fold_builtin_ceil (location_t, tree, tree);
 163 static tree fold_builtin_round (location_t, tree, tree);
 164 static tree fold_builtin_int_roundingfn (location_t, tree, tree);
 165 static tree fold_builtin_bitop (tree, tree);
 166 static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
 167 static tree fold_builtin_strchr (location_t, tree, tree, tree);
 168 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
 169 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
 170 static tree fold_builtin_strcmp (location_t, tree, tree);
 171 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
 172 static tree fold_builtin_signbit (location_t, tree, tree);
 173 static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
 174 static tree fold_builtin_isascii (location_t, tree);
 175 static tree fold_builtin_toascii (location_t, tree);
 176 static tree fold_builtin_isdigit (location_t, tree);
 177 static tree fold_builtin_fabs (location_t, tree, tree);
 178 static tree fold_builtin_abs (location_t, tree, tree);
 179 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
 180                                         enum tree_code);
 181 static tree fold_builtin_n (location_t, tree, tree *, int, bool);
 182 static tree fold_builtin_0 (location_t, tree, bool);
 183 static tree fold_builtin_1 (location_t, tree, tree, bool);
 184 static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
 185 static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
 186 static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
 187 static tree fold_builtin_varargs (location_t, tree, tree, bool);
 188
 189 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
 190 static tree fold_builtin_strstr (location_t, tree, tree, tree);
 191 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
 192 static tree fold_builtin_strcat (location_t, tree, tree);
 193 static tree fold_builtin_strncat (location_t, tree, tree, tree);
 194 static tree fold_builtin_strspn (location_t, tree, tree);
 195 static tree fold_builtin_strcspn (location_t, tree, tree);
 196 static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
 197
 198 static rtx expand_builtin_object_size (tree);
 199 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
 200                                       enum built_in_function);
 201 static void maybe_emit_chk_warning (tree, enum built_in_function);
 202 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 203 static void maybe_emit_free_warning (tree);
 204 static tree fold_builtin_object_size (tree, tree);
 205 static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
 206 static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
 207 static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
 208 static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
 209 static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
 210                                   enum built_in_function);
 211 static bool init_target_chars (void);
 212
 213 static unsigned HOST_WIDE_INT target_newline;
 214 static unsigned HOST_WIDE_INT target_percent;
 215 static unsigned HOST_WIDE_INT target_c;
 216 static unsigned HOST_WIDE_INT target_s;
 217 static char target_percent_c[3];
 218 static char target_percent_s[3];
 219 static char target_percent_s_newline[4];
 220 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
 221                           const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
 222 static tree do_mpfr_arg2 (tree, tree, tree,
 223                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 224 static tree do_mpfr_arg3 (tree, tree, tree, tree,
 225                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 226 static tree do_mpfr_sincos (tree, tree, tree);
 227 static tree do_mpfr_bessel_n (tree, tree, tree,
 228                               int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
 229                               const REAL_VALUE_TYPE *, bool);
 230 static tree do_mpfr_remquo (tree, tree, tree);
 231 static tree do_mpfr_lgamma_r (tree, tree, tree);
 232
 233 /* Return true if NAME starts with __builtin_ or __sync_.  */
 234
 235 bool
 236 is_builtin_name (const char *name)
 237 {
 238   if (strncmp (name, "__builtin_", 10) == 0)
 239     return true;
 240   if (strncmp (name, "__sync_", 7) == 0)
 241     return true;
 242   return false;
 243 }
 244
 245
 246 /* Return true if DECL is a function symbol representing a built-in.  */
 247
 248 bool
 249 is_builtin_fn (tree decl)
 250 {
 251   return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
 252 }
 253
 254
 255 /* Return true if NODE should be considered for inline expansion regardless
 256    of the optimization level.  This means whenever a function is invoked with
 257    its "internal" name, which normally contains the prefix "__builtin".  */
 258
 259 static bool
 260 called_as_built_in (tree node)
 261 {
 262   /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
 263      we want the name used to call the function, not the name it
 264      will have. */
 265   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 266   return is_builtin_name (name);
 267 }
 268
 269 /* Return the alignment in bits of EXP, an object.
 270    Don't return more than MAX_ALIGN no matter what.  */
 271
 272 unsigned int
 273 get_object_alignment (tree exp, unsigned int max_align)
 274 {
 275   HOST_WIDE_INT bitsize, bitpos;
 276   tree offset;
 277   enum machine_mode mode;
 278   int unsignedp, volatilep;
 279   unsigned int align, inner;
 280
 281   /* Get the innermost object and the constant (bitpos) and possibly
 282      variable (offset) offset of the access.  */
 283   exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
 284                              &mode, &unsignedp, &volatilep, true);
 285
 286   /* Extract alignment information from the innermost object and
 287      possibly adjust bitpos and offset.  */
 288   if (TREE_CODE (exp) == CONST_DECL)
 289     exp = DECL_INITIAL (exp);
 290   if (DECL_P (exp)
 291       && TREE_CODE (exp) != LABEL_DECL)
 292     align = DECL_ALIGN (exp);
 293   else if (CONSTANT_CLASS_P (exp))
 294     {
 295       align = TYPE_ALIGN (TREE_TYPE (exp));
 296 #ifdef CONSTANT_ALIGNMENT
 297       align = (unsigned)CONSTANT_ALIGNMENT (exp, align);
 298 #endif
 299     }
 300   else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
 301     align = TYPE_ALIGN (TREE_TYPE (exp));
 302   else if (TREE_CODE (exp) == INDIRECT_REF)
 303     align = TYPE_ALIGN (TREE_TYPE (exp));
 304   else if (TREE_CODE (exp) == 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    SUBTARGET may be used as the target for computing one of EXP's operands.  */
2343
2344 static rtx
2345 expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
2346 {
2347   enum insn_code icode = CODE_FOR_nothing;
2348   rtx op0;
2349   tree fndecl = get_callee_fndecl (exp);
2350   enum machine_mode mode;
2351   tree arg;
2352
2353   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2354     return NULL_RTX;
2355
2356   arg = CALL_EXPR_ARG (exp, 0);
2357   icode = interclass_mathfn_icode (arg, fndecl);
2358   mode = TYPE_MODE (TREE_TYPE (arg));
2359
2360   if (icode != CODE_FOR_nothing)
2361     {
2362       rtx last = get_last_insn ();
2363       tree orig_arg = arg;
2364       /* Make a suitable register to place result in.  */
2365       if (!target
2366           || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp))
2367           || !insn_data[icode].operand[0].predicate (target, GET_MODE (target)))
2368          target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2369
2370       gcc_assert (insn_data[icode].operand[0].predicate
2371                   (target, GET_MODE (target)));
2372
2373       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2374          need to expand the argument again.  This way, we will not perform
2375          side-effects more the once.  */
2376       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2377
2378       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2379
2380       if (mode != GET_MODE (op0))
2381         op0 = convert_to_mode (mode, op0, 0);
2382
2383       /* Compute into TARGET.
2384          Set TARGET to wherever the result comes back.  */
2385       if (maybe_emit_unop_insn (icode, target, op0, UNKNOWN))
2386         return target;
2387       delete_insns_since (last);
2388       CALL_EXPR_ARG (exp, 0) = orig_arg;
2389     }
2390
2391   return NULL_RTX;
2392 }
2393
2394 /* Expand a call to the builtin sincos math function.
2395    Return NULL_RTX if a normal call should be emitted rather than expanding the
2396    function in-line.  EXP is the expression that is a call to the builtin
2397    function.  */
2398
2399 static rtx
2400 expand_builtin_sincos (tree exp)
2401 {
2402   rtx op0, op1, op2, target1, target2;
2403   enum machine_mode mode;
2404   tree arg, sinp, cosp;
2405   int result;
2406   location_t loc = EXPR_LOCATION (exp);
2407
2408   if (!validate_arglist (exp, REAL_TYPE,
2409                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2410     return NULL_RTX;
2411
2412   arg = CALL_EXPR_ARG (exp, 0);
2413   sinp = CALL_EXPR_ARG (exp, 1);
2414   cosp = CALL_EXPR_ARG (exp, 2);
2415
2416   /* Make a suitable register to place result in.  */
2417   mode = TYPE_MODE (TREE_TYPE (arg));
2418
2419   /* Check if sincos insn is available, otherwise emit the call.  */
2420   if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2421     return NULL_RTX;
2422
2423   target1 = gen_reg_rtx (mode);
2424   target2 = gen_reg_rtx (mode);
2425
2426   op0 = expand_normal (arg);
2427   op1 = expand_normal (build_fold_indirect_ref_loc (loc, sinp));
2428   op2 = expand_normal (build_fold_indirect_ref_loc (loc, cosp));
2429
2430   /* Compute into target1 and target2.
2431      Set TARGET to wherever the result comes back.  */
2432   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2433   gcc_assert (result);
2434
2435   /* Move target1 and target2 to the memory locations indicated
2436      by op1 and op2.  */
2437   emit_move_insn (op1, target1);
2438   emit_move_insn (op2, target2);
2439
2440   return const0_rtx;
2441 }
2442
2443 /* Expand a call to the internal cexpi builtin to the sincos math function.
2444    EXP is the expression that is a call to the builtin function; if convenient,
2445    the result should be placed in TARGET.  SUBTARGET may be used as the target
2446    for computing one of EXP's operands.  */
2447
2448 static rtx
2449 expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
2450 {
2451   tree fndecl = get_callee_fndecl (exp);
2452   tree arg, type;
2453   enum machine_mode mode;
2454   rtx op0, op1, op2;
2455   location_t loc = EXPR_LOCATION (exp);
2456
2457   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2458     return NULL_RTX;
2459
2460   arg = CALL_EXPR_ARG (exp, 0);
2461   type = TREE_TYPE (arg);
2462   mode = TYPE_MODE (TREE_TYPE (arg));
2463
2464   /* Try expanding via a sincos optab, fall back to emitting a libcall
2465      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2466      is only generated from sincos, cexp or if we have either of them.  */
2467   if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2468     {
2469       op1 = gen_reg_rtx (mode);
2470       op2 = gen_reg_rtx (mode);
2471
2472       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2473
2474       /* Compute into op1 and op2.  */
2475       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2476     }
2477   else if (TARGET_HAS_SINCOS)
2478     {
2479       tree call, fn = NULL_TREE;
2480       tree top1, top2;
2481       rtx op1a, op2a;
2482
2483       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2484         fn = built_in_decls[BUILT_IN_SINCOSF];
2485       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2486         fn = built_in_decls[BUILT_IN_SINCOS];
2487       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2488         fn = built_in_decls[BUILT_IN_SINCOSL];
2489       else
2490         gcc_unreachable ();
2491
2492       op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2493       op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2494       op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2495       op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2496       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2497       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2498
2499       /* Make sure not to fold the sincos call again.  */
2500       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2501       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2502                                       call, 3, arg, top1, top2));
2503     }
2504   else
2505     {
2506       tree call, fn = NULL_TREE, narg;
2507       tree ctype = build_complex_type (type);
2508
2509       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2510         fn = built_in_decls[BUILT_IN_CEXPF];
2511       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2512         fn = built_in_decls[BUILT_IN_CEXP];
2513       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2514         fn = built_in_decls[BUILT_IN_CEXPL];
2515       else
2516         gcc_unreachable ();
2517
2518       /* If we don't have a decl for cexp create one.  This is the
2519          friendliest fallback if the user calls __builtin_cexpi
2520          without full target C99 function support.  */
2521       if (fn == NULL_TREE)
2522         {
2523           tree fntype;
2524           const char *name = NULL;
2525
2526           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2527             name = "cexpf";
2528           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2529             name = "cexp";
2530           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2531             name = "cexpl";
2532
2533           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2534           fn = build_fn_decl (name, fntype);
2535         }
2536
2537       narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2538                           build_real (type, dconst0), arg);
2539
2540       /* Make sure not to fold the cexp call again.  */
2541       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2542       return expand_expr (build_call_nary (ctype, call, 1, narg),
2543                           target, VOIDmode, EXPAND_NORMAL);
2544     }
2545
2546   /* Now build the proper return type.  */
2547   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2548                               make_tree (TREE_TYPE (arg), op2),
2549                               make_tree (TREE_TYPE (arg), op1)),
2550                       target, VOIDmode, EXPAND_NORMAL);
2551 }
2552
2553 /* Conveniently construct a function call expression.  FNDECL names the
2554    function to be called, N is the number of arguments, and the "..."
2555    parameters are the argument expressions.  Unlike build_call_exr
2556    this doesn't fold the call, hence it will always return a CALL_EXPR.  */
2557
2558 static tree
2559 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2560 {
2561   va_list ap;
2562   tree fntype = TREE_TYPE (fndecl);
2563   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2564
2565   va_start (ap, n);
2566   fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2567   va_end (ap);
2568   SET_EXPR_LOCATION (fn, loc);
2569   return fn;
2570 }
2571
2572 /* Expand a call to one of the builtin rounding functions gcc defines
2573    as an extension (lfloor and lceil).  As these are gcc extensions we
2574    do not need to worry about setting errno to EDOM.
2575    If expanding via optab fails, lower expression to (int)(floor(x)).
2576    EXP is the expression that is a call to the builtin function;
2577    if convenient, the result should be placed in TARGET.  */
2578
2579 static rtx
2580 expand_builtin_int_roundingfn (tree exp, rtx target)
2581 {
2582   convert_optab builtin_optab;
2583   rtx op0, insns, tmp;
2584   tree fndecl = get_callee_fndecl (exp);
2585   enum built_in_function fallback_fn;
2586   tree fallback_fndecl;
2587   enum machine_mode mode;
2588   tree arg;
2589
2590   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2591     gcc_unreachable ();
2592
2593   arg = CALL_EXPR_ARG (exp, 0);
2594
2595   switch (DECL_FUNCTION_CODE (fndecl))
2596     {
2597     CASE_FLT_FN (BUILT_IN_LCEIL):
2598     CASE_FLT_FN (BUILT_IN_LLCEIL):
2599       builtin_optab = lceil_optab;
2600       fallback_fn = BUILT_IN_CEIL;
2601       break;
2602
2603     CASE_FLT_FN (BUILT_IN_LFLOOR):
2604     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2605       builtin_optab = lfloor_optab;
2606       fallback_fn = BUILT_IN_FLOOR;
2607       break;
2608
2609     default:
2610       gcc_unreachable ();
2611     }
2612
2613   /* Make a suitable register to place result in.  */
2614   mode = TYPE_MODE (TREE_TYPE (exp));
2615
2616   target = gen_reg_rtx (mode);
2617
2618   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2619      need to expand the argument again.  This way, we will not perform
2620      side-effects more the once.  */
2621   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2622
2623   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2624
2625   start_sequence ();
2626
2627   /* Compute into TARGET.  */
2628   if (expand_sfix_optab (target, op0, builtin_optab))
2629     {
2630       /* Output the entire sequence.  */
2631       insns = get_insns ();
2632       end_sequence ();
2633       emit_insn (insns);
2634       return target;
2635     }
2636
2637   /* If we were unable to expand via the builtin, stop the sequence
2638      (without outputting the insns).  */
2639   end_sequence ();
2640
2641   /* Fall back to floating point rounding optab.  */
2642   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2643
2644   /* For non-C99 targets we may end up without a fallback fndecl here
2645      if the user called __builtin_lfloor directly.  In this case emit
2646      a call to the floor/ceil variants nevertheless.  This should result
2647      in the best user experience for not full C99 targets.  */
2648   if (fallback_fndecl == NULL_TREE)
2649     {
2650       tree fntype;
2651       const char *name = NULL;
2652
2653       switch (DECL_FUNCTION_CODE (fndecl))
2654         {
2655         case BUILT_IN_LCEIL:
2656         case BUILT_IN_LLCEIL:
2657           name = "ceil";
2658           break;
2659         case BUILT_IN_LCEILF:
2660         case BUILT_IN_LLCEILF:
2661           name = "ceilf";
2662           break;
2663         case BUILT_IN_LCEILL:
2664         case BUILT_IN_LLCEILL:
2665           name = "ceill";
2666           break;
2667         case BUILT_IN_LFLOOR:
2668         case BUILT_IN_LLFLOOR:
2669           name = "floor";
2670           break;
2671         case BUILT_IN_LFLOORF:
2672         case BUILT_IN_LLFLOORF:
2673           name = "floorf";
2674           break;
2675         case BUILT_IN_LFLOORL:
2676         case BUILT_IN_LLFLOORL:
2677           name = "floorl";
2678           break;
2679         default:
2680           gcc_unreachable ();
2681         }
2682
2683       fntype = build_function_type_list (TREE_TYPE (arg),
2684                                          TREE_TYPE (arg), NULL_TREE);
2685       fallback_fndecl = build_fn_decl (name, fntype);
2686     }
2687
2688   exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2689
2690   tmp = expand_normal (exp);
2691
2692   /* Truncate the result of floating point optab to integer
2693      via expand_fix ().  */
2694   target = gen_reg_rtx (mode);
2695   expand_fix (target, tmp, 0);
2696
2697   return target;
2698 }
2699
2700 /* Expand a call to one of the builtin math functions doing integer
2701    conversion (lrint).
2702    Return 0 if a normal call should be emitted rather than expanding the
2703    function in-line.  EXP is the expression that is a call to the builtin
2704    function; if convenient, the result should be placed in TARGET.  */
2705
2706 static rtx
2707 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2708 {
2709   convert_optab builtin_optab;
2710   rtx op0, insns;
2711   tree fndecl = get_callee_fndecl (exp);
2712   tree arg;
2713   enum machine_mode mode;
2714
2715   /* There's no easy way to detect the case we need to set EDOM.  */
2716   if (flag_errno_math)
2717     return NULL_RTX;
2718
2719   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2720      gcc_unreachable ();
2721
2722   arg = CALL_EXPR_ARG (exp, 0);
2723
2724   switch (DECL_FUNCTION_CODE (fndecl))
2725     {
2726     CASE_FLT_FN (BUILT_IN_LRINT):
2727     CASE_FLT_FN (BUILT_IN_LLRINT):
2728       builtin_optab = lrint_optab; break;
2729     CASE_FLT_FN (BUILT_IN_LROUND):
2730     CASE_FLT_FN (BUILT_IN_LLROUND):
2731       builtin_optab = lround_optab; break;
2732     default:
2733       gcc_unreachable ();
2734     }
2735
2736   /* Make a suitable register to place result in.  */
2737   mode = TYPE_MODE (TREE_TYPE (exp));
2738
2739   target = gen_reg_rtx (mode);
2740
2741   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2742      need to expand the argument again.  This way, we will not perform
2743      side-effects more the once.  */
2744   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2745
2746   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2747
2748   start_sequence ();
2749
2750   if (expand_sfix_optab (target, op0, builtin_optab))
2751     {
2752       /* Output the entire sequence.  */
2753       insns = get_insns ();
2754       end_sequence ();
2755       emit_insn (insns);
2756       return target;
2757     }
2758
2759   /* If we were unable to expand via the builtin, stop the sequence
2760      (without outputting the insns) and call to the library function
2761      with the stabilized argument list.  */
2762   end_sequence ();
2763
2764   target = expand_call (exp, target, target == const0_rtx);
2765
2766   return target;
2767 }
2768
2769 /* To evaluate powi(x,n), the floating point value x raised to the
2770    constant integer exponent n, we use a hybrid algorithm that
2771    combines the "window method" with look-up tables.  For an
2772    introduction to exponentiation algorithms and "addition chains",
2773    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2774    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2775    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2776    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2777
2778 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2779    multiplications to inline before calling the system library's pow
2780    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2781    so this default never requires calling pow, powf or powl.  */
2782
2783 #ifndef POWI_MAX_MULTS
2784 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2785 #endif
2786
2787 /* The size of the "optimal power tree" lookup table.  All
2788    exponents less than this value are simply looked up in the
2789    powi_table below.  This threshold is also used to size the
2790    cache of pseudo registers that hold intermediate results.  */
2791 #define POWI_TABLE_SIZE 256
2792
2793 /* The size, in bits of the window, used in the "window method"
2794    exponentiation algorithm.  This is equivalent to a radix of
2795    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2796 #define POWI_WINDOW_SIZE 3
2797
2798 /* The following table is an efficient representation of an
2799    "optimal power tree".  For each value, i, the corresponding
2800    value, j, in the table states than an optimal evaluation
2801    sequence for calculating pow(x,i) can be found by evaluating
2802    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2803    100 integers is given in Knuth's "Seminumerical algorithms".  */
2804
2805 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2806   {
2807       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2808       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2809       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2810      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2811      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2812      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2813      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2814      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2815      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2816      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2817      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2818      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2819      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2820      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2821      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2822      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2823      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2824      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2825      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2826      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2827      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2828      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2829      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2830      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2831      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2832     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2833     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2834     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2835     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2836     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2837     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2838     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2839   };
2840
2841
2842 /* Return the number of multiplications required to calculate
2843    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2844    subroutine of powi_cost.  CACHE is an array indicating
2845    which exponents have already been calculated.  */
2846
2847 static int
2848 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2849 {
2850   /* If we've already calculated this exponent, then this evaluation
2851      doesn't require any additional multiplications.  */
2852   if (cache[n])
2853     return 0;
2854
2855   cache[n] = true;
2856   return powi_lookup_cost (n - powi_table[n], cache)
2857          + powi_lookup_cost (powi_table[n], cache) + 1;
2858 }
2859
2860 /* Return the number of multiplications required to calculate
2861    powi(x,n) for an arbitrary x, given the exponent N.  This
2862    function needs to be kept in sync with expand_powi below.  */
2863
2864 static int
2865 powi_cost (HOST_WIDE_INT n)
2866 {
2867   bool cache[POWI_TABLE_SIZE];
2868   unsigned HOST_WIDE_INT digit;
2869   unsigned HOST_WIDE_INT val;
2870   int result;
2871
2872   if (n == 0)
2873     return 0;
2874
2875   /* Ignore the reciprocal when calculating the cost.  */
2876   val = (n < 0) ? -n : n;
2877
2878   /* Initialize the exponent cache.  */
2879   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2880   cache[1] = true;
2881
2882   result = 0;
2883
2884   while (val >= POWI_TABLE_SIZE)
2885     {
2886       if (val & 1)
2887         {
2888           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2889           result += powi_lookup_cost (digit, cache)
2890                     + POWI_WINDOW_SIZE + 1;
2891           val >>= POWI_WINDOW_SIZE;
2892         }
2893       else
2894         {
2895           val >>= 1;
2896           result++;
2897         }
2898     }
2899
2900   return result + powi_lookup_cost (val, cache);
2901 }
2902
2903 /* Recursive subroutine of expand_powi.  This function takes the array,
2904    CACHE, of already calculated exponents and an exponent N and returns
2905    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2906
2907 static rtx
2908 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2909 {
2910   unsigned HOST_WIDE_INT digit;
2911   rtx target, result;
2912   rtx op0, op1;
2913
2914   if (n < POWI_TABLE_SIZE)
2915     {
2916       if (cache[n])
2917         return cache[n];
2918
2919       target = gen_reg_rtx (mode);
2920       cache[n] = target;
2921
2922       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2923       op1 = expand_powi_1 (mode, powi_table[n], cache);
2924     }
2925   else if (n & 1)
2926     {
2927       target = gen_reg_rtx (mode);
2928       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2929       op0 = expand_powi_1 (mode, n - digit, cache);
2930       op1 = expand_powi_1 (mode, digit, cache);
2931     }
2932   else
2933     {
2934       target = gen_reg_rtx (mode);
2935       op0 = expand_powi_1 (mode, n >> 1, cache);
2936       op1 = op0;
2937     }
2938
2939   result = expand_mult (mode, op0, op1, target, 0);
2940   if (result != target)
2941     emit_move_insn (target, result);
2942   return target;
2943 }
2944
2945 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
2946    floating point operand in mode MODE, and N is the exponent.  This
2947    function needs to be kept in sync with powi_cost above.  */
2948
2949 static rtx
2950 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2951 {
2952   rtx cache[POWI_TABLE_SIZE];
2953   rtx result;
2954
2955   if (n == 0)
2956     return CONST1_RTX (mode);
2957
2958   memset (cache, 0, sizeof (cache));
2959   cache[1] = x;
2960
2961   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2962
2963   /* If the original exponent was negative, reciprocate the result.  */
2964   if (n < 0)
2965     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2966                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2967
2968   return result;
2969 }
2970
2971 /* Fold a builtin function call to pow, powf, or powl into a series of sqrts or
2972    cbrts.  Return NULL_RTX if no simplification can be made or expand the tree
2973    if we can simplify it.  */
2974 static rtx
2975 expand_builtin_pow_root (location_t loc, tree arg0, tree arg1, tree type,
2976                          rtx subtarget)
2977 {
2978   if (TREE_CODE (arg1) == REAL_CST
2979       && !TREE_OVERFLOW (arg1)
2980       && flag_unsafe_math_optimizations)
2981     {
2982       enum machine_mode mode = TYPE_MODE (type);
2983       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
2984       tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
2985       REAL_VALUE_TYPE c = TREE_REAL_CST (arg1);
2986       tree op = NULL_TREE;
2987
2988       if (sqrtfn)
2989         {
2990           /* Optimize pow (x, 0.5) into sqrt.  */
2991           if (REAL_VALUES_EQUAL (c, dconsthalf))
2992             op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
2993
2994           else
2995             {
2996               REAL_VALUE_TYPE dconst1_4 = dconst1;
2997               REAL_VALUE_TYPE dconst3_4;
2998               SET_REAL_EXP (&dconst1_4, REAL_EXP (&dconst1_4) - 2);
2999
3000               real_from_integer (&dconst3_4, VOIDmode, 3, 0, 0);
3001               SET_REAL_EXP (&dconst3_4, REAL_EXP (&dconst3_4) - 2);
3002
3003               /* Optimize pow (x, 0.25) into sqrt (sqrt (x)).  Assume on most
3004                  machines that a builtin sqrt instruction is smaller than a
3005                  call to pow with 0.25, so do this optimization even if
3006                  -Os.  */
3007               if (REAL_VALUES_EQUAL (c, dconst1_4))
3008                 {
3009                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3010                   op = build_call_nofold_loc (loc, sqrtfn, 1, op);
3011                 }
3012
3013               /* Optimize pow (x, 0.75) = sqrt (x) * sqrt (sqrt (x)) unless we
3014                  are optimizing for space.  */
3015               else if (optimize_insn_for_speed_p ()
3016                        && !TREE_SIDE_EFFECTS (arg0)
3017                        && REAL_VALUES_EQUAL (c, dconst3_4))
3018                 {
3019                   tree sqrt1 = build_call_expr_loc (loc, sqrtfn, 1, arg0);
3020                   tree sqrt2 = builtin_save_expr (sqrt1);
3021                   tree sqrt3 = build_call_expr_loc (loc, sqrtfn, 1, sqrt1);
3022                   op = fold_build2_loc (loc, MULT_EXPR, type, sqrt2, sqrt3);
3023                 }
3024             }
3025         }
3026
3027       /* Check whether we can do cbrt insstead of pow (x, 1./3.) and
3028          cbrt/sqrts instead of pow (x, 1./6.).  */
3029       if (cbrtfn && ! op
3030           && (tree_expr_nonnegative_p (arg0) || !HONOR_NANS (mode)))
3031         {
3032           /* First try 1/3.  */
3033           REAL_VALUE_TYPE dconst1_3
3034             = real_value_truncate (mode, dconst_third ());
3035
3036           if (REAL_VALUES_EQUAL (c, dconst1_3))
3037             op = build_call_nofold_loc (loc, cbrtfn, 1, arg0);
3038
3039               /* Now try 1/6.  */
3040           else if (optimize_insn_for_speed_p ())
3041             {
3042               REAL_VALUE_TYPE dconst1_6 = dconst1_3;
3043               SET_REAL_EXP (&dconst1_6, REAL_EXP (&dconst1_6) - 1);
3044
3045               if (REAL_VALUES_EQUAL (c, dconst1_6))
3046                 {
3047                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3048                   op = build_call_nofold_loc (loc, cbrtfn, 1, op);
3049                 }
3050             }
3051         }
3052
3053       if (op)
3054         return expand_expr (op, subtarget, mode, EXPAND_NORMAL);
3055     }
3056
3057   return NULL_RTX;
3058 }
3059
3060 /* Expand a call to the pow built-in mathematical function.  Return NULL_RTX if
3061    a normal call should be emitted rather than expanding the function
3062    in-line.  EXP is the expression that is a call to the builtin
3063    function; if convenient, the result should be placed in TARGET.  */
3064
3065 static rtx
3066 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
3067 {
3068   tree arg0, arg1;
3069   tree fn, narg0;
3070   tree type = TREE_TYPE (exp);
3071   REAL_VALUE_TYPE cint, c, c2;
3072   HOST_WIDE_INT n;
3073   rtx op, op2;
3074   enum machine_mode mode = TYPE_MODE (type);
3075
3076   if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
3077     return NULL_RTX;
3078
3079   arg0 = CALL_EXPR_ARG (exp, 0);
3080   arg1 = CALL_EXPR_ARG (exp, 1);
3081
3082   if (TREE_CODE (arg1) != REAL_CST
3083       || TREE_OVERFLOW (arg1))
3084     return expand_builtin_mathfn_2 (exp, target, subtarget);
3085
3086   /* Handle constant exponents.  */
3087
3088   /* For integer valued exponents we can expand to an optimal multiplication
3089      sequence using expand_powi.  */
3090   c = TREE_REAL_CST (arg1);
3091   n = real_to_integer (&c);
3092   real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3093   if (real_identical (&c, &cint)
3094       && ((n >= -1 && n <= 2)
3095           || (flag_unsafe_math_optimizations
3096               && optimize_insn_for_speed_p ()
3097               && powi_cost (n) <= POWI_MAX_MULTS)))
3098     {
3099       op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3100       if (n != 1)
3101         {
3102           op = force_reg (mode, op);
3103           op = expand_powi (op, mode, n);
3104         }
3105       return op;
3106     }
3107
3108   narg0 = builtin_save_expr (arg0);
3109
3110   /* If the exponent is not integer valued, check if it is half of an integer.
3111      In this case we can expand to sqrt (x) * x**(n/2).  */
3112   fn = mathfn_built_in (type, BUILT_IN_SQRT);
3113   if (fn != NULL_TREE)
3114     {
3115       real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
3116       n = real_to_integer (&c2);
3117       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3118       if (real_identical (&c2, &cint)
3119           && ((flag_unsafe_math_optimizations
3120                && optimize_insn_for_speed_p ()
3121                && powi_cost (n/2) <= POWI_MAX_MULTS)
3122               /* Even the c == 0.5 case cannot be done unconditionally
3123                  when we need to preserve signed zeros, as
3124                  pow (-0, 0.5) is +0, while sqrt(-0) is -0.  */
3125               || (!HONOR_SIGNED_ZEROS (mode) && n == 1)
3126               /* For c == 1.5 we can assume that x * sqrt (x) is always
3127                  smaller than pow (x, 1.5) if sqrt will not be expanded
3128                  as a call.  */
3129               || (n == 3
3130                   && optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)))
3131         {
3132           tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3133                                                   narg0);
3134           /* Use expand_expr in case the newly built call expression
3135              was folded to a non-call.  */
3136           op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
3137           if (n != 1)
3138             {
3139               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3140               op2 = force_reg (mode, op2);
3141               op2 = expand_powi (op2, mode, abs (n / 2));
3142               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3143                                         0, OPTAB_LIB_WIDEN);
3144               /* If the original exponent was negative, reciprocate the
3145                  result.  */
3146               if (n < 0)
3147                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3148                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3149             }
3150           return op;
3151         }
3152     }
3153
3154   /* Check whether we can do a series of sqrt or cbrt's instead of the pow
3155      call.  */
3156   op = expand_builtin_pow_root (EXPR_LOCATION (exp), arg0, arg1, type,
3157                                 subtarget);
3158   if (op)
3159     return op;
3160
3161   /* Try if the exponent is a third of an integer.  In this case
3162      we can expand to x**(n/3) * cbrt(x)**(n%3).  As cbrt (x) is
3163      different from pow (x, 1./3.) due to rounding and behavior
3164      with negative x we need to constrain this transformation to
3165      unsafe math and positive x or finite math.  */
3166   fn = mathfn_built_in (type, BUILT_IN_CBRT);
3167   if (fn != NULL_TREE
3168       && flag_unsafe_math_optimizations
3169       && (tree_expr_nonnegative_p (arg0)
3170           || !HONOR_NANS (mode)))
3171     {
3172       REAL_VALUE_TYPE dconst3;
3173       real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3174       real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3175       real_round (&c2, mode, &c2);
3176       n = real_to_integer (&c2);
3177       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3178       real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3179       real_convert (&c2, mode, &c2);
3180       if (real_identical (&c2, &c)
3181           && ((optimize_insn_for_speed_p ()
3182                && powi_cost (n/3) <= POWI_MAX_MULTS)
3183               || n == 1))
3184         {
3185           tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3186                                                   narg0);
3187           op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3188           if (abs (n) % 3 == 2)
3189             op = expand_simple_binop (mode, MULT, op, op, op,
3190                                       0, OPTAB_LIB_WIDEN);
3191           if (n != 1)
3192             {
3193               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3194               op2 = force_reg (mode, op2);
3195               op2 = expand_powi (op2, mode, abs (n / 3));
3196               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3197                                         0, OPTAB_LIB_WIDEN);
3198               /* If the original exponent was negative, reciprocate the
3199                  result.  */
3200               if (n < 0)
3201                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3202                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3203             }
3204           return op;
3205         }
3206     }
3207
3208   /* Fall back to optab expansion.  */
3209   return expand_builtin_mathfn_2 (exp, target, subtarget);
3210 }
3211
3212 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
3213    a normal call should be emitted rather than expanding the function
3214    in-line.  EXP is the expression that is a call to the builtin
3215    function; if convenient, the result should be placed in TARGET.  */
3216
3217 static rtx
3218 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
3219 {
3220   tree arg0, arg1;
3221   rtx op0, op1;
3222   enum machine_mode mode;
3223   enum machine_mode mode2;
3224
3225   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3226     return NULL_RTX;
3227
3228   arg0 = CALL_EXPR_ARG (exp, 0);
3229   arg1 = CALL_EXPR_ARG (exp, 1);
3230   mode = TYPE_MODE (TREE_TYPE (exp));
3231
3232   /* Handle constant power.  */
3233
3234   if (TREE_CODE (arg1) == INTEGER_CST
3235       && !TREE_OVERFLOW (arg1))
3236     {
3237       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3238
3239       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3240          Otherwise, check the number of multiplications required.  */
3241       if ((TREE_INT_CST_HIGH (arg1) == 0
3242            || TREE_INT_CST_HIGH (arg1) == -1)
3243           && ((n >= -1 && n <= 2)
3244               || (optimize_insn_for_speed_p ()
3245                   && powi_cost (n) <= POWI_MAX_MULTS)))
3246         {
3247           op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3248           op0 = force_reg (mode, op0);
3249           return expand_powi (op0, mode, n);
3250         }
3251     }
3252
3253   /* Emit a libcall to libgcc.  */
3254
3255   /* Mode of the 2nd argument must match that of an int.  */
3256   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3257
3258   if (target == NULL_RTX)
3259     target = gen_reg_rtx (mode);
3260
3261   op0 = expand_expr (arg0, subtarget, mode, EXPAND_NORMAL);
3262   if (GET_MODE (op0) != mode)
3263     op0 = convert_to_mode (mode, op0, 0);
3264   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3265   if (GET_MODE (op1) != mode2)
3266     op1 = convert_to_mode (mode2, op1, 0);
3267
3268   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3269                                     target, LCT_CONST, mode, 2,
3270                                     op0, mode, op1, mode2);
3271
3272   return target;
3273 }
3274
3275 /* Expand expression EXP which is a call to the strlen builtin.  Return
3276    NULL_RTX if we failed the caller should emit a normal call, otherwise
3277    try to get the result in TARGET, if convenient.  */
3278
3279 static rtx
3280 expand_builtin_strlen (tree exp, rtx target,
3281                        enum machine_mode target_mode)
3282 {
3283   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3284     return NULL_RTX;
3285   else
3286     {
3287       rtx pat;
3288       tree len;
3289       tree src = CALL_EXPR_ARG (exp, 0);
3290       rtx result, src_reg, char_rtx, before_strlen;
3291       enum machine_mode insn_mode = target_mode, char_mode;
3292       enum insn_code icode = CODE_FOR_nothing;
3293       unsigned int align;
3294
3295       /* If the length can be computed at compile-time, return it.  */
3296       len = c_strlen (src, 0);
3297       if (len)
3298         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3299
3300       /* If the length can be computed at compile-time and is constant
3301          integer, but there are side-effects in src, evaluate
3302          src for side-effects, then return len.
3303          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3304          can be optimized into: i++; x = 3;  */
3305       len = c_strlen (src, 1);
3306       if (len && TREE_CODE (len) == INTEGER_CST)
3307         {
3308           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3309           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3310         }
3311
3312       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3313
3314       /* If SRC is not a pointer type, don't do this operation inline.  */
3315       if (align == 0)
3316         return NULL_RTX;
3317
3318       /* Bail out if we can't compute strlen in the right mode.  */
3319       while (insn_mode != VOIDmode)
3320         {
3321           icode = optab_handler (strlen_optab, insn_mode);
3322           if (icode != CODE_FOR_nothing)
3323             break;
3324
3325           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3326         }
3327       if (insn_mode == VOIDmode)
3328         return NULL_RTX;
3329
3330       /* Make a place to write the result of the instruction.  */
3331       result = target;
3332       if (! (result != 0
3333              && REG_P (result)
3334              && GET_MODE (result) == insn_mode
3335              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3336         result = gen_reg_rtx (insn_mode);
3337
3338       /* Make a place to hold the source address.  We will not expand
3339          the actual source until we are sure that the expansion will
3340          not fail -- there are trees that cannot be expanded twice.  */
3341       src_reg = gen_reg_rtx (Pmode);
3342
3343       /* Mark the beginning of the strlen sequence so we can emit the
3344          source operand later.  */
3345       before_strlen = get_last_insn ();
3346
3347       char_rtx = const0_rtx;
3348       char_mode = insn_data[(int) icode].operand[2].mode;
3349       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3350                                                             char_mode))
3351         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3352
3353       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3354                              char_rtx, GEN_INT (align));
3355       if (! pat)
3356         return NULL_RTX;
3357       emit_insn (pat);
3358
3359       /* Now that we are assured of success, expand the source.  */
3360       start_sequence ();
3361       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3362       if (pat != src_reg)
3363         emit_move_insn (src_reg, pat);
3364       pat = get_insns ();
3365       end_sequence ();
3366
3367       if (before_strlen)
3368         emit_insn_after (pat, before_strlen);
3369       else
3370         emit_insn_before (pat, get_insns ());
3371
3372       /* Return the value in the proper mode for this function.  */
3373       if (GET_MODE (result) == target_mode)
3374         target = result;
3375       else if (target != 0)
3376         convert_move (target, result, 0);
3377       else
3378         target = convert_to_mode (target_mode, result, 0);
3379
3380       return target;
3381     }
3382 }
3383
3384 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3385    bytes from constant string DATA + OFFSET and return it as target
3386    constant.  */
3387
3388 static rtx
3389 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3390                          enum machine_mode mode)
3391 {
3392   const char *str = (const char *) data;
3393
3394   gcc_assert (offset >= 0
3395               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3396                   <= strlen (str) + 1));
3397
3398   return c_readstr (str + offset, mode);
3399 }
3400
3401 /* Expand a call EXP to the memcpy builtin.
3402    Return NULL_RTX if we failed, the caller should emit a normal call,
3403    otherwise try to get the result in TARGET, if convenient (and in
3404    mode MODE if that's convenient).  */
3405
3406 static rtx
3407 expand_builtin_memcpy (tree exp, rtx target)
3408 {
3409   if (!validate_arglist (exp,
3410                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3411     return NULL_RTX;
3412   else
3413     {
3414       tree dest = CALL_EXPR_ARG (exp, 0);
3415       tree src = CALL_EXPR_ARG (exp, 1);
3416       tree len = CALL_EXPR_ARG (exp, 2);
3417       const char *src_str;
3418       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3419       unsigned int dest_align
3420         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3421       rtx dest_mem, src_mem, dest_addr, len_rtx;
3422       HOST_WIDE_INT expected_size = -1;
3423       unsigned int expected_align = 0;
3424
3425       /* If DEST is not a pointer type, call the normal function.  */
3426       if (dest_align == 0)
3427         return NULL_RTX;
3428
3429       /* If either SRC is not a pointer type, don't do this
3430          operation in-line.  */
3431       if (src_align == 0)
3432         return NULL_RTX;
3433
3434       if (currently_expanding_gimple_stmt)
3435         stringop_block_profile (currently_expanding_gimple_stmt,
3436                                 &expected_align, &expected_size);
3437
3438       if (expected_align < dest_align)
3439         expected_align = dest_align;
3440       dest_mem = get_memory_rtx (dest, len);
3441       set_mem_align (dest_mem, dest_align);
3442       len_rtx = expand_normal (len);
3443       src_str = c_getstr (src);
3444
3445       /* If SRC is a string constant and block move would be done
3446          by pieces, we can avoid loading the string from memory
3447          and only stored the computed constants.  */
3448       if (src_str
3449           && CONST_INT_P (len_rtx)
3450           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3451           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3452                                   CONST_CAST (char *, src_str),
3453                                   dest_align, false))
3454         {
3455           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3456                                       builtin_memcpy_read_str,
3457                                       CONST_CAST (char *, src_str),
3458                                       dest_align, false, 0);
3459           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3460           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3461           return dest_mem;
3462         }
3463
3464       src_mem = get_memory_rtx (src, len);
3465       set_mem_align (src_mem, src_align);
3466
3467       /* Copy word part most expediently.  */
3468       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3469                                          CALL_EXPR_TAILCALL (exp)
3470                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3471                                          expected_align, expected_size);
3472
3473       if (dest_addr == 0)
3474         {
3475           dest_addr = force_operand (XEXP (dest_mem, 0), target);
3476           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3477         }
3478       return dest_addr;
3479     }
3480 }
3481
3482 /* Expand a call EXP to the mempcpy builtin.
3483    Return NULL_RTX if we failed; the caller should emit a normal call,
3484    otherwise try to get the result in TARGET, if convenient (and in
3485    mode MODE if that's convenient).  If ENDP is 0 return the
3486    destination pointer, if ENDP is 1 return the end pointer ala
3487    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3488    stpcpy.  */
3489
3490 static rtx
3491 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3492 {
3493   if (!validate_arglist (exp,
3494                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3495     return NULL_RTX;
3496   else
3497     {
3498       tree dest = CALL_EXPR_ARG (exp, 0);
3499       tree src = CALL_EXPR_ARG (exp, 1);
3500       tree len = CALL_EXPR_ARG (exp, 2);
3501       return expand_builtin_mempcpy_args (dest, src, len,
3502                                           target, mode, /*endp=*/ 1);
3503     }
3504 }
3505
3506 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3507    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3508    so that this can also be called without constructing an actual CALL_EXPR.
3509    The other arguments and return value are the same as for
3510    expand_builtin_mempcpy.  */
3511
3512 static rtx
3513 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3514                              rtx target, enum machine_mode mode, int endp)
3515 {
3516     /* If return value is ignored, transform mempcpy into memcpy.  */
3517   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3518     {
3519       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3520       tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3521                                            dest, src, len);
3522       return expand_expr (result, target, mode, EXPAND_NORMAL);
3523     }
3524   else
3525     {
3526       const char *src_str;
3527       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3528       unsigned int dest_align
3529         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3530       rtx dest_mem, src_mem, len_rtx;
3531
3532       /* If either SRC or DEST is not a pointer type, don't do this
3533          operation in-line.  */
3534       if (dest_align == 0 || src_align == 0)
3535         return NULL_RTX;
3536
3537       /* If LEN is not constant, call the normal function.  */
3538       if (! host_integerp (len, 1))
3539         return NULL_RTX;
3540
3541       len_rtx = expand_normal (len);
3542       src_str = c_getstr (src);
3543
3544       /* If SRC is a string constant and block move would be done
3545          by pieces, we can avoid loading the string from memory
3546          and only stored the computed constants.  */
3547       if (src_str
3548           && CONST_INT_P (len_rtx)
3549           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3550           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3551                                   CONST_CAST (char *, src_str),
3552                                   dest_align, false))
3553         {
3554           dest_mem = get_memory_rtx (dest, len);
3555           set_mem_align (dest_mem, dest_align);
3556           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3557                                       builtin_memcpy_read_str,
3558                                       CONST_CAST (char *, src_str),
3559                                       dest_align, false, endp);
3560           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3561           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3562           return dest_mem;
3563         }
3564
3565       if (CONST_INT_P (len_rtx)
3566           && can_move_by_pieces (INTVAL (len_rtx),
3567                                  MIN (dest_align, src_align)))
3568         {
3569           dest_mem = get_memory_rtx (dest, len);
3570           set_mem_align (dest_mem, dest_align);
3571           src_mem = get_memory_rtx (src, len);
3572           set_mem_align (src_mem, src_align);
3573           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3574                                      MIN (dest_align, src_align), endp);
3575           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3576           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3577           return dest_mem;
3578         }
3579
3580       return NULL_RTX;
3581     }
3582 }
3583
3584 #ifndef HAVE_movstr
3585 # define HAVE_movstr 0
3586 # define CODE_FOR_movstr CODE_FOR_nothing
3587 #endif
3588
3589 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3590    we failed, the caller should emit a normal call, otherwise try to
3591    get the result in TARGET, if convenient.  If ENDP is 0 return the
3592    destination pointer, if ENDP is 1 return the end pointer ala
3593    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3594    stpcpy.  */
3595
3596 static rtx
3597 expand_movstr (tree dest, tree src, rtx target, int endp)
3598 {
3599   rtx end;
3600   rtx dest_mem;
3601   rtx src_mem;
3602   rtx insn;
3603   const struct insn_data_d * data;
3604
3605   if (!HAVE_movstr)
3606     return NULL_RTX;
3607
3608   dest_mem = get_memory_rtx (dest, NULL);
3609   src_mem = get_memory_rtx (src, NULL);
3610   data = insn_data + CODE_FOR_movstr;
3611   if (!endp)
3612     {
3613       target = force_reg (Pmode, XEXP (dest_mem, 0));
3614       dest_mem = replace_equiv_address (dest_mem, target);
3615       end = gen_reg_rtx (Pmode);
3616     }
3617   else
3618     {
3619       if (target == 0
3620           || target == const0_rtx
3621           || ! (*data->operand[0].predicate) (target, Pmode))
3622         {
3623           end = gen_reg_rtx (Pmode);
3624           if (target != const0_rtx)
3625             target = end;
3626         }
3627       else
3628         end = target;
3629     }
3630
3631   if (data->operand[0].mode != VOIDmode)
3632     end = gen_lowpart (data->operand[0].mode, end);
3633
3634   insn = data->genfun (end, dest_mem, src_mem);
3635
3636   gcc_assert (insn);
3637
3638   emit_insn (insn);
3639
3640   /* movstr is supposed to set end to the address of the NUL
3641      terminator.  If the caller requested a mempcpy-like return value,
3642      adjust it.  */
3643   if (endp == 1 && target != const0_rtx)
3644     {
3645       rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3646       emit_move_insn (target, force_operand (tem, NULL_RTX));
3647     }
3648
3649   return target;
3650 }
3651
3652 /* Expand expression EXP, which is a call to the strcpy builtin.  Return
3653    NULL_RTX if we failed the caller should emit a normal call, otherwise
3654    try to get the result in TARGET, if convenient (and in mode MODE if that's
3655    convenient).  */
3656
3657 static rtx
3658 expand_builtin_strcpy (tree exp, rtx target)
3659 {
3660   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3661    {
3662      tree dest = CALL_EXPR_ARG (exp, 0);
3663      tree src = CALL_EXPR_ARG (exp, 1);
3664      return expand_builtin_strcpy_args (dest, src, target);
3665    }
3666    return NULL_RTX;
3667 }
3668
3669 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3670    arguments to the builtin_strcpy call DEST and SRC are broken out
3671    so that this can also be called without constructing an actual CALL_EXPR.
3672    The other arguments and return value are the same as for
3673    expand_builtin_strcpy.  */
3674
3675 static rtx
3676 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3677 {
3678   return expand_movstr (dest, src, target, /*endp=*/0);
3679 }
3680
3681 /* Expand a call EXP to the stpcpy builtin.
3682    Return NULL_RTX if we failed the caller should emit a normal call,
3683    otherwise try to get the result in TARGET, if convenient (and in
3684    mode MODE if that's convenient).  */
3685
3686 static rtx
3687 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3688 {
3689   tree dst, src;
3690   location_t loc = EXPR_LOCATION (exp);
3691
3692   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3693     return NULL_RTX;
3694
3695   dst = CALL_EXPR_ARG (exp, 0);
3696   src = CALL_EXPR_ARG (exp, 1);
3697
3698   /* If return value is ignored, transform stpcpy into strcpy.  */
3699   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3700     {
3701       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3702       tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3703       return expand_expr (result, target, mode, EXPAND_NORMAL);
3704     }
3705   else
3706     {
3707       tree len, lenp1;
3708       rtx ret;
3709
3710       /* Ensure we get an actual string whose length can be evaluated at
3711          compile-time, not an expression containing a string.  This is
3712          because the latter will potentially produce pessimized code
3713          when used to produce the return value.  */
3714       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3715         return expand_movstr (dst, src, target, /*endp=*/2);
3716
3717       lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3718       ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3719                                          target, mode, /*endp=*/2);
3720
3721       if (ret)
3722         return ret;
3723
3724       if (TREE_CODE (len) == INTEGER_CST)
3725         {
3726           rtx len_rtx = expand_normal (len);
3727
3728           if (CONST_INT_P (len_rtx))
3729             {
3730               ret = expand_builtin_strcpy_args (dst, src, target);
3731
3732               if (ret)
3733                 {
3734                   if (! target)
3735                     {
3736                       if (mode != VOIDmode)
3737                         target = gen_reg_rtx (mode);
3738                       else
3739                         target = gen_reg_rtx (GET_MODE (ret));
3740                     }
3741                   if (GET_MODE (target) != GET_MODE (ret))
3742                     ret = gen_lowpart (GET_MODE (target), ret);
3743
3744                   ret = plus_constant (ret, INTVAL (len_rtx));
3745                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3746                   gcc_assert (ret);
3747
3748                   return target;
3749                 }
3750             }
3751         }
3752
3753       return expand_movstr (dst, src, target, /*endp=*/2);
3754     }
3755 }
3756
3757 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3758    bytes from constant string DATA + OFFSET and return it as target
3759    constant.  */
3760
3761 rtx
3762 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3763                           enum machine_mode mode)
3764 {
3765   const char *str = (const char *) data;
3766
3767   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3768     return const0_rtx;
3769
3770   return c_readstr (str + offset, mode);
3771 }
3772
3773 /* Expand expression EXP, which is a call to the strncpy builtin.  Return
3774    NULL_RTX if we failed the caller should emit a normal call.  */
3775
3776 static rtx
3777 expand_builtin_strncpy (tree exp, rtx target)
3778 {
3779   location_t loc = EXPR_LOCATION (exp);
3780
3781   if (validate_arglist (exp,
3782                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3783     {
3784       tree dest = CALL_EXPR_ARG (exp, 0);
3785       tree src = CALL_EXPR_ARG (exp, 1);
3786       tree len = CALL_EXPR_ARG (exp, 2);
3787       tree slen = c_strlen (src, 1);
3788
3789       /* We must be passed a constant len and src parameter.  */
3790       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3791         return NULL_RTX;
3792
3793       slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3794
3795       /* We're required to pad with trailing zeros if the requested
3796          len is greater than strlen(s2)+1.  In that case try to
3797          use store_by_pieces, if it fails, punt.  */
3798       if (tree_int_cst_lt (slen, len))
3799         {
3800           unsigned int dest_align
3801             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3802           const char *p = c_getstr (src);
3803           rtx dest_mem;
3804
3805           if (!p || dest_align == 0 || !host_integerp (len, 1)
3806               || !can_store_by_pieces (tree_low_cst (len, 1),
3807                                        builtin_strncpy_read_str,
3808                                        CONST_CAST (char *, p),
3809                                        dest_align, false))
3810             return NULL_RTX;
3811
3812           dest_mem = get_memory_rtx (dest, len);
3813           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3814                            builtin_strncpy_read_str,
3815                            CONST_CAST (char *, p), dest_align, false, 0);
3816           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3817           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3818           return dest_mem;
3819         }
3820     }
3821   return NULL_RTX;
3822 }
3823
3824 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3825    bytes from constant string DATA + OFFSET and return it as target
3826    constant.  */
3827
3828 rtx
3829 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3830                          enum machine_mode mode)
3831 {
3832   const char *c = (const char *) data;
3833   char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3834
3835   memset (p, *c, GET_MODE_SIZE (mode));
3836
3837   return c_readstr (p, mode);
3838 }
3839
3840 /* Callback routine for store_by_pieces.  Return the RTL of a register
3841    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3842    char value given in the RTL register data.  For example, if mode is
3843    4 bytes wide, return the RTL for 0x01010101*data.  */
3844
3845 static rtx
3846 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3847                         enum machine_mode mode)
3848 {
3849   rtx target, coeff;
3850   size_t size;
3851   char *p;
3852
3853   size = GET_MODE_SIZE (mode);
3854   if (size == 1)
3855     return (rtx) data;
3856
3857   p = XALLOCAVEC (char, size);
3858   memset (p, 1, size);
3859   coeff = c_readstr (p, mode);
3860
3861   target = convert_to_mode (mode, (rtx) data, 1);
3862   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3863   return force_reg (mode, target);
3864 }
3865
3866 /* Expand expression EXP, which is a call to the memset builtin.  Return
3867    NULL_RTX if we failed the caller should emit a normal call, otherwise
3868    try to get the result in TARGET, if convenient (and in mode MODE if that's
3869    convenient).  */
3870
3871 static rtx
3872 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3873 {
3874   if (!validate_arglist (exp,
3875                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3876     return NULL_RTX;
3877   else
3878     {
3879       tree dest = CALL_EXPR_ARG (exp, 0);
3880       tree val = CALL_EXPR_ARG (exp, 1);
3881       tree len = CALL_EXPR_ARG (exp, 2);
3882       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3883     }
3884 }
3885
3886 /* Helper function to do the actual work for expand_builtin_memset.  The
3887    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3888    so that this can also be called without constructing an actual CALL_EXPR.
3889    The other arguments and return value are the same as for
3890    expand_builtin_memset.  */
3891
3892 static rtx
3893 expand_builtin_memset_args (tree dest, tree val, tree len,
3894                             rtx target, enum machine_mode mode, tree orig_exp)
3895 {
3896   tree fndecl, fn;
3897   enum built_in_function fcode;
3898   char c;
3899   unsigned int dest_align;
3900   rtx dest_mem, dest_addr, len_rtx;
3901   HOST_WIDE_INT expected_size = -1;
3902   unsigned int expected_align = 0;
3903
3904   dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3905
3906   /* If DEST is not a pointer type, don't do this operation in-line.  */
3907   if (dest_align == 0)
3908     return NULL_RTX;
3909
3910   if (currently_expanding_gimple_stmt)
3911     stringop_block_profile (currently_expanding_gimple_stmt,
3912                             &expected_align, &expected_size);
3913
3914   if (expected_align < dest_align)
3915     expected_align = dest_align;
3916
3917   /* If the LEN parameter is zero, return DEST.  */
3918   if (integer_zerop (len))
3919     {
3920       /* Evaluate and ignore VAL in case it has side-effects.  */
3921       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3922       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3923     }
3924
3925   /* Stabilize the arguments in case we fail.  */
3926   dest = builtin_save_expr (dest);
3927   val = builtin_save_expr (val);
3928   len = builtin_save_expr (len);
3929
3930   len_rtx = expand_normal (len);
3931   dest_mem = get_memory_rtx (dest, len);
3932
3933   if (TREE_CODE (val) != INTEGER_CST)
3934     {
3935       rtx val_rtx;
3936
3937       val_rtx = expand_normal (val);
3938       val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3939                                  val_rtx, 0);
3940
3941       /* Assume that we can memset by pieces if we can store
3942        * the coefficients by pieces (in the required modes).
3943        * We can't pass builtin_memset_gen_str as that emits RTL.  */
3944       c = 1;
3945       if (host_integerp (len, 1)
3946           && can_store_by_pieces (tree_low_cst (len, 1),
3947                                   builtin_memset_read_str, &c, dest_align,
3948                                   true))
3949         {
3950           val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3951                                val_rtx);
3952           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3953                            builtin_memset_gen_str, val_rtx, dest_align,
3954                            true, 0);
3955         }
3956       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3957                                         dest_align, expected_align,
3958                                         expected_size))
3959         goto do_libcall;
3960
3961       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3962       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3963       return dest_mem;
3964     }
3965
3966   if (target_char_cast (val, &c))
3967     goto do_libcall;
3968
3969   if (c)
3970     {
3971       if (host_integerp (len, 1)
3972           && can_store_by_pieces (tree_low_cst (len, 1),
3973                                   builtin_memset_read_str, &c, dest_align,
3974                                   true))
3975         store_by_pieces (dest_mem, tree_low_cst (len, 1),
3976                          builtin_memset_read_str, &c, dest_align, true, 0);
3977       else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3978                                         dest_align, expected_align,
3979                                         expected_size))
3980         goto do_libcall;
3981
3982       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3983       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3984       return dest_mem;
3985     }
3986
3987   set_mem_align (dest_mem, dest_align);
3988   dest_addr = clear_storage_hints (dest_mem, len_rtx,
3989                                    CALL_EXPR_TAILCALL (orig_exp)
3990                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3991                                    expected_align, expected_size);
3992
3993   if (dest_addr == 0)
3994     {
3995       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3996       dest_addr = convert_memory_address (ptr_mode, dest_addr);
3997     }
3998
3999   return dest_addr;
4000
4001  do_libcall:
4002   fndecl = get_callee_fndecl (orig_exp);
4003   fcode = DECL_FUNCTION_CODE (fndecl);
4004   if (fcode == BUILT_IN_MEMSET)
4005     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
4006                                 dest, val, len);
4007   else if (fcode == BUILT_IN_BZERO)
4008     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
4009                                 dest, len);
4010   else
4011     gcc_unreachable ();
4012   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4013   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
4014   return expand_call (fn, target, target == const0_rtx);
4015 }
4016
4017 /* Expand expression EXP, which is a call to the bzero builtin.  Return
4018    NULL_RTX if we failed the caller should emit a normal call.  */
4019
4020 static rtx
4021 expand_builtin_bzero (tree exp)
4022 {
4023   tree dest, size;
4024   location_t loc = EXPR_LOCATION (exp);
4025
4026   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4027     return NULL_RTX;
4028
4029   dest = CALL_EXPR_ARG (exp, 0);
4030   size = CALL_EXPR_ARG (exp, 1);
4031
4032   /* New argument list transforming bzero(ptr x, int y) to
4033      memset(ptr x, int 0, size_t y).   This is done this way
4034      so that if it isn't expanded inline, we fallback to
4035      calling bzero instead of memset.  */
4036
4037   return expand_builtin_memset_args (dest, integer_zero_node,
4038                                      fold_convert_loc (loc, sizetype, size),
4039                                      const0_rtx, VOIDmode, exp);
4040 }
4041
4042 /* Expand expression EXP, which is a call to the memcmp built-in function.
4043    Return NULL_RTX if we failed and the
4044    caller should emit a normal call, otherwise try to get the result in
4045    TARGET, if convenient (and in mode MODE, if that's convenient).  */
4046
4047 static rtx
4048 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4049                        ATTRIBUTE_UNUSED enum machine_mode mode)
4050 {
4051   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4052
4053   if (!validate_arglist (exp,
4054                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4055     return NULL_RTX;
4056
4057 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4058   {
4059     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4060     rtx result;
4061     rtx insn;
4062     tree arg1 = CALL_EXPR_ARG (exp, 0);
4063     tree arg2 = CALL_EXPR_ARG (exp, 1);
4064     tree len = CALL_EXPR_ARG (exp, 2);
4065
4066     unsigned int arg1_align
4067       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4068     unsigned int arg2_align
4069       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4070     enum machine_mode insn_mode;
4071
4072 #ifdef HAVE_cmpmemsi
4073     if (HAVE_cmpmemsi)
4074       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
4075     else
4076 #endif
4077 #ifdef HAVE_cmpstrnsi
4078     if (HAVE_cmpstrnsi)
4079       insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4080     else
4081 #endif
4082       return NULL_RTX;
4083
4084     /* If we don't have POINTER_TYPE, call the function.  */
4085     if (arg1_align == 0 || arg2_align == 0)
4086       return NULL_RTX;
4087
4088     /* Make a place to write the result of the instruction.  */
4089     result = target;
4090     if (! (result != 0
4091            && REG_P (result) && GET_MODE (result) == insn_mode
4092            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4093       result = gen_reg_rtx (insn_mode);
4094
4095     arg1_rtx = get_memory_rtx (arg1, len);
4096     arg2_rtx = get_memory_rtx (arg2, len);
4097     arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
4098
4099     /* Set MEM_SIZE as appropriate.  */
4100     if (CONST_INT_P (arg3_rtx))
4101       {
4102         set_mem_size (arg1_rtx, arg3_rtx);
4103         set_mem_size (arg2_rtx, arg3_rtx);
4104       }
4105
4106 #ifdef HAVE_cmpmemsi
4107     if (HAVE_cmpmemsi)
4108       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4109                            GEN_INT (MIN (arg1_align, arg2_align)));
4110     else
4111 #endif
4112 #ifdef HAVE_cmpstrnsi
4113     if (HAVE_cmpstrnsi)
4114       insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4115                             GEN_INT (MIN (arg1_align, arg2_align)));
4116     else
4117 #endif
4118       gcc_unreachable ();
4119
4120     if (insn)
4121       emit_insn (insn);
4122     else
4123       emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
4124                                TYPE_MODE (integer_type_node), 3,
4125                                XEXP (arg1_rtx, 0), Pmode,
4126                                XEXP (arg2_rtx, 0), Pmode,
4127                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
4128                                                 TYPE_UNSIGNED (sizetype)),
4129                                TYPE_MODE (sizetype));
4130
4131     /* Return the value in the proper mode for this function.  */
4132     mode = TYPE_MODE (TREE_TYPE (exp));
4133     if (GET_MODE (result) == mode)
4134       return result;
4135     else if (target != 0)
4136       {
4137         convert_move (target, result, 0);
4138         return target;
4139       }
4140     else
4141       return convert_to_mode (mode, result, 0);
4142   }
4143 #endif
4144
4145   return NULL_RTX;
4146 }
4147
4148 /* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
4149    if we failed the caller should emit a normal call, otherwise try to get
4150    the result in TARGET, if convenient.  */
4151
4152 static rtx
4153 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
4154 {
4155   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4156     return NULL_RTX;
4157
4158 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4159   if (direct_optab_handler (cmpstr_optab, SImode) != CODE_FOR_nothing
4160       || direct_optab_handler (cmpstrn_optab, SImode) != CODE_FOR_nothing)
4161     {
4162       rtx arg1_rtx, arg2_rtx;
4163       rtx result, insn = NULL_RTX;
4164       tree fndecl, fn;
4165       tree arg1 = CALL_EXPR_ARG (exp, 0);
4166       tree arg2 = CALL_EXPR_ARG (exp, 1);
4167
4168       unsigned int arg1_align
4169         = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4170       unsigned int arg2_align
4171         = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4172
4173       /* If we don't have POINTER_TYPE, call the function.  */
4174       if (arg1_align == 0 || arg2_align == 0)
4175         return NULL_RTX;
4176
4177       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
4178       arg1 = builtin_save_expr (arg1);
4179       arg2 = builtin_save_expr (arg2);
4180
4181       arg1_rtx = get_memory_rtx (arg1, NULL);
4182       arg2_rtx = get_memory_rtx (arg2, NULL);
4183
4184 #ifdef HAVE_cmpstrsi
4185       /* Try to call cmpstrsi.  */
4186       if (HAVE_cmpstrsi)
4187         {
4188           enum machine_mode insn_mode
4189             = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4190
4191           /* Make a place to write the result of the instruction.  */
4192           result = target;
4193           if (! (result != 0
4194                  && REG_P (result) && GET_MODE (result) == insn_mode
4195                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4196             result = gen_reg_rtx (insn_mode);
4197
4198           insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4199                                GEN_INT (MIN (arg1_align, arg2_align)));
4200         }
4201 #endif
4202 #ifdef HAVE_cmpstrnsi
4203       /* Try to determine at least one length and call cmpstrnsi.  */
4204       if (!insn && HAVE_cmpstrnsi)
4205         {
4206           tree len;
4207           rtx arg3_rtx;
4208
4209           enum machine_mode insn_mode
4210             = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4211           tree len1 = c_strlen (arg1, 1);
4212           tree len2 = c_strlen (arg2, 1);
4213
4214           if (len1)
4215             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4216           if (len2)
4217             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4218
4219           /* If we don't have a constant length for the first, use the length
4220              of the second, if we know it.  We don't require a constant for
4221              this case; some cost analysis could be done if both are available
4222              but neither is constant.  For now, assume they're equally cheap,
4223              unless one has side effects.  If both strings have constant lengths,
4224              use the smaller.  */
4225
4226           if (!len1)
4227             len = len2;
4228           else if (!len2)
4229             len = len1;
4230           else if (TREE_SIDE_EFFECTS (len1))
4231             len = len2;
4232           else if (TREE_SIDE_EFFECTS (len2))
4233             len = len1;
4234           else if (TREE_CODE (len1) != INTEGER_CST)
4235             len = len2;
4236           else if (TREE_CODE (len2) != INTEGER_CST)
4237             len = len1;
4238           else if (tree_int_cst_lt (len1, len2))
4239             len = len1;
4240           else
4241             len = len2;
4242
4243           /* If both arguments have side effects, we cannot optimize.  */
4244           if (!len || TREE_SIDE_EFFECTS (len))
4245             goto do_libcall;
4246
4247           arg3_rtx = expand_normal (len);
4248
4249           /* Make a place to write the result of the instruction.  */
4250           result = target;
4251           if (! (result != 0
4252                  && REG_P (result) && GET_MODE (result) == insn_mode
4253                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4254             result = gen_reg_rtx (insn_mode);
4255
4256           insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4257                                 GEN_INT (MIN (arg1_align, arg2_align)));
4258         }
4259 #endif
4260
4261       if (insn)
4262         {
4263           enum machine_mode mode;
4264           emit_insn (insn);
4265
4266           /* Return the value in the proper mode for this function.  */
4267           mode = TYPE_MODE (TREE_TYPE (exp));
4268           if (GET_MODE (result) == mode)
4269             return result;
4270           if (target == 0)
4271             return convert_to_mode (mode, result, 0);
4272           convert_move (target, result, 0);
4273           return target;
4274         }
4275
4276       /* Expand the library call ourselves using a stabilized argument
4277          list to avoid re-evaluating the function's arguments twice.  */
4278 #ifdef HAVE_cmpstrnsi
4279     do_libcall:
4280 #endif
4281       fndecl = get_callee_fndecl (exp);
4282       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
4283       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4284       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4285       return expand_call (fn, target, target == const0_rtx);
4286     }
4287 #endif
4288   return NULL_RTX;
4289 }
4290
4291 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4292    NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4293    the result in TARGET, if convenient.  */
4294
4295 static rtx
4296 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4297                         ATTRIBUTE_UNUSED enum machine_mode mode)
4298 {
4299   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4300
4301   if (!validate_arglist (exp,
4302                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4303     return NULL_RTX;
4304
4305   /* If c_strlen can determine an expression for one of the string
4306      lengths, and it doesn't have side effects, then emit cmpstrnsi
4307      using length MIN(strlen(string)+1, arg3).  */
4308 #ifdef HAVE_cmpstrnsi
4309   if (HAVE_cmpstrnsi)
4310   {
4311     tree len, len1, len2;
4312     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4313     rtx result, insn;
4314     tree fndecl, fn;
4315     tree arg1 = CALL_EXPR_ARG (exp, 0);
4316     tree arg2 = CALL_EXPR_ARG (exp, 1);
4317     tree arg3 = CALL_EXPR_ARG (exp, 2);
4318
4319     unsigned int arg1_align
4320       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4321     unsigned int arg2_align
4322       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4323     enum machine_mode insn_mode
4324       = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4325
4326     len1 = c_strlen (arg1, 1);
4327     len2 = c_strlen (arg2, 1);
4328
4329     if (len1)
4330       len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
4331     if (len2)
4332       len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
4333
4334     /* If we don't have a constant length for the first, use the length
4335        of the second, if we know it.  We don't require a constant for
4336        this case; some cost analysis could be done if both are available
4337        but neither is constant.  For now, assume they're equally cheap,
4338        unless one has side effects.  If both strings have constant lengths,
4339        use the smaller.  */
4340
4341     if (!len1)
4342       len = len2;
4343     else if (!len2)
4344       len = len1;
4345     else if (TREE_SIDE_EFFECTS (len1))
4346       len = len2;
4347     else if (TREE_SIDE_EFFECTS (len2))
4348       len = len1;
4349     else if (TREE_CODE (len1) != INTEGER_CST)
4350       len = len2;
4351     else if (TREE_CODE (len2) != INTEGER_CST)
4352       len = len1;
4353     else if (tree_int_cst_lt (len1, len2))
4354       len = len1;
4355     else
4356       len = len2;
4357
4358     /* If both arguments have side effects, we cannot optimize.  */
4359     if (!len || TREE_SIDE_EFFECTS (len))
4360       return NULL_RTX;
4361
4362     /* The actual new length parameter is MIN(len,arg3).  */
4363     len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4364                        fold_convert_loc (loc, TREE_TYPE (len), arg3));
4365
4366     /* If we don't have POINTER_TYPE, call the function.  */
4367     if (arg1_align == 0 || arg2_align == 0)
4368       return NULL_RTX;
4369
4370     /* Make a place to write the result of the instruction.  */
4371     result = target;
4372     if (! (result != 0
4373            && REG_P (result) && GET_MODE (result) == insn_mode
4374            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4375       result = gen_reg_rtx (insn_mode);
4376
4377     /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
4378     arg1 = builtin_save_expr (arg1);
4379     arg2 = builtin_save_expr (arg2);
4380     len = builtin_save_expr (len);
4381
4382     arg1_rtx = get_memory_rtx (arg1, len);
4383     arg2_rtx = get_memory_rtx (arg2, len);
4384     arg3_rtx = expand_normal (len);
4385     insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4386                           GEN_INT (MIN (arg1_align, arg2_align)));
4387     if (insn)
4388       {
4389         emit_insn (insn);
4390
4391         /* Return the value in the proper mode for this function.  */
4392         mode = TYPE_MODE (TREE_TYPE (exp));
4393         if (GET_MODE (result) == mode)
4394           return result;
4395         if (target == 0)
4396           return convert_to_mode (mode, result, 0);
4397         convert_move (target, result, 0);
4398         return target;
4399       }
4400
4401     /* Expand the library call ourselves using a stabilized argument
4402        list to avoid re-evaluating the function's arguments twice.  */
4403     fndecl = get_callee_fndecl (exp);
4404     fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
4405                                 arg1, arg2, len);
4406     gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4407     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4408     return expand_call (fn, target, target == const0_rtx);
4409   }
4410 #endif
4411   return NULL_RTX;
4412 }
4413
4414 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4415    if that's convenient.  */
4416
4417 rtx
4418 expand_builtin_saveregs (void)
4419 {
4420   rtx val, seq;
4421
4422   /* Don't do __builtin_saveregs more than once in a function.
4423      Save the result of the first call and reuse it.  */
4424   if (saveregs_value != 0)
4425     return saveregs_value;
4426
4427   /* When this function is called, it means that registers must be
4428      saved on entry to this function.  So we migrate the call to the
4429      first insn of this function.  */
4430
4431   start_sequence ();
4432
4433   /* Do whatever the machine needs done in this case.  */
4434   val = targetm.calls.expand_builtin_saveregs ();
4435
4436   seq = get_insns ();
4437   end_sequence ();
4438
4439   saveregs_value = val;
4440
4441   /* Put the insns after the NOTE that starts the function.  If this
4442      is inside a start_sequence, make the outer-level insn chain current, so
4443      the code is placed at the start of the function.  */
4444   push_topmost_sequence ();
4445   emit_insn_after (seq, entry_of_function ());
4446   pop_topmost_sequence ();
4447
4448   return val;
4449 }
4450
4451 /* Expand a call to __builtin_next_arg.  */
4452
4453 static rtx
4454 expand_builtin_next_arg (void)
4455 {
4456   /* Checking arguments is already done in fold_builtin_next_arg
4457      that must be called before this function.  */
4458   return expand_binop (ptr_mode, add_optab,
4459                        crtl->args.internal_arg_pointer,
4460                        crtl->args.arg_offset_rtx,
4461                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
4462 }
4463
4464 /* Make it easier for the backends by protecting the valist argument
4465    from multiple evaluations.  */
4466
4467 static tree
4468 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4469 {
4470   tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4471
4472   /* The current way of determining the type of valist is completely
4473      bogus.  We should have the information on the va builtin instead.  */
4474   if (!vatype)
4475     vatype = targetm.fn_abi_va_list (cfun->decl);
4476
4477   if (TREE_CODE (vatype) == ARRAY_TYPE)
4478     {
4479       if (TREE_SIDE_EFFECTS (valist))
4480         valist = save_expr (valist);
4481
4482       /* For this case, the backends will be expecting a pointer to
4483          vatype, but it's possible we've actually been given an array
4484          (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4485          So fix it.  */
4486       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4487         {
4488           tree p1 = build_pointer_type (TREE_TYPE (vatype));
4489           valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4490         }
4491     }
4492   else
4493     {
4494       tree pt = build_pointer_type (vatype);
4495
4496       if (! needs_lvalue)
4497         {
4498           if (! TREE_SIDE_EFFECTS (valist))
4499             return valist;
4500
4501           valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4502           TREE_SIDE_EFFECTS (valist) = 1;
4503         }
4504
4505       if (TREE_SIDE_EFFECTS (valist))
4506         valist = save_expr (valist);
4507       valist = fold_build2_loc (loc, MEM_REF,
4508                                 vatype, valist, build_int_cst (pt, 0));
4509     }
4510
4511   return valist;
4512 }
4513
4514 /* The "standard" definition of va_list is void*.  */
4515
4516 tree
4517 std_build_builtin_va_list (void)
4518 {
4519   return ptr_type_node;
4520 }
4521
4522 /* The "standard" abi va_list is va_list_type_node.  */
4523
4524 tree
4525 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4526 {
4527   return va_list_type_node;
4528 }
4529
4530 /* The "standard" type of va_list is va_list_type_node.  */
4531
4532 tree
4533 std_canonical_va_list_type (tree type)
4534 {
4535   tree wtype, htype;
4536
4537   if (INDIRECT_REF_P (type))
4538     type = TREE_TYPE (type);
4539   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4540     type = TREE_TYPE (type);
4541   wtype = va_list_type_node;
4542   htype = type;
4543   /* Treat structure va_list types.  */
4544   if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4545     htype = TREE_TYPE (htype);
4546   else if (TREE_CODE (wtype) == ARRAY_TYPE)
4547     {
4548       /* If va_list is an array type, the argument may have decayed
4549          to a pointer type, e.g. by being passed to another function.
4550          In that case, unwrap both types so that we can compare the
4551          underlying records.  */
4552       if (TREE_CODE (htype) == ARRAY_TYPE
4553           || POINTER_TYPE_P (htype))
4554         {
4555           wtype = TREE_TYPE (wtype);
4556           htype = TREE_TYPE (htype);
4557         }
4558     }
4559   if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4560     return va_list_type_node;
4561
4562   return NULL_TREE;
4563 }
4564
4565 /* The "standard" implementation of va_start: just assign `nextarg' to
4566    the variable.  */
4567
4568 void
4569 std_expand_builtin_va_start (tree valist, rtx nextarg)
4570 {
4571   rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4572   convert_move (va_r, nextarg, 0);
4573 }
4574
4575 /* Expand EXP, a call to __builtin_va_start.  */
4576
4577 static rtx
4578 expand_builtin_va_start (tree exp)
4579 {
4580   rtx nextarg;
4581   tree valist;
4582   location_t loc = EXPR_LOCATION (exp);
4583
4584   if (call_expr_nargs (exp) < 2)
4585     {
4586       error_at (loc, "too few arguments to function %<va_start%>");
4587       return const0_rtx;
4588     }
4589
4590   if (fold_builtin_next_arg (exp, true))
4591     return const0_rtx;
4592
4593   nextarg = expand_builtin_next_arg ();
4594   valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4595
4596   if (targetm.expand_builtin_va_start)
4597     targetm.expand_builtin_va_start (valist, nextarg);
4598   else
4599     std_expand_builtin_va_start (valist, nextarg);
4600
4601   return const0_rtx;
4602 }
4603
4604 /* The "standard" implementation of va_arg: read the value from the
4605    current (padded) address and increment by the (padded) size.  */
4606
4607 tree
4608 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4609                           gimple_seq *post_p)
4610 {
4611   tree addr, t, type_size, rounded_size, valist_tmp;
4612   unsigned HOST_WIDE_INT align, boundary;
4613   bool indirect;
4614
4615 #ifdef ARGS_GROW_DOWNWARD
4616   /* All of the alignment and movement below is for args-grow-up machines.
4617      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4618      implement their own specialized gimplify_va_arg_expr routines.  */
4619   gcc_unreachable ();
4620 #endif
4621
4622   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4623   if (indirect)
4624     type = build_pointer_type (type);
4625
4626   align = PARM_BOUNDARY / BITS_PER_UNIT;
4627   boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
4628
4629   /* When we align parameter on stack for caller, if the parameter
4630      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4631      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
4632      here with caller.  */
4633   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4634     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4635
4636   boundary /= BITS_PER_UNIT;
4637
4638   /* Hoist the valist value into a temporary for the moment.  */
4639   valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4640
4641   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
4642      requires greater alignment, we must perform dynamic alignment.  */
4643   if (boundary > align
4644       && !integer_zerop (TYPE_SIZE (type)))
4645     {
4646       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4647                   fold_build2 (POINTER_PLUS_EXPR,
4648                                TREE_TYPE (valist),
4649                                valist_tmp, size_int (boundary - 1)));
4650       gimplify_and_add (t, pre_p);
4651
4652       t = fold_convert (sizetype, valist_tmp);
4653       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4654                   fold_convert (TREE_TYPE (valist),
4655                                 fold_build2 (BIT_AND_EXPR, sizetype, t,
4656                                              size_int (-boundary))));
4657       gimplify_and_add (t, pre_p);
4658     }
4659   else
4660     boundary = align;
4661
4662   /* If the actual alignment is less than the alignment of the type,
4663      adjust the type accordingly so that we don't assume strict alignment
4664      when dereferencing the pointer.  */
4665   boundary *= BITS_PER_UNIT;
4666   if (boundary < TYPE_ALIGN (type))
4667     {
4668       type = build_variant_type_copy (type);
4669       TYPE_ALIGN (type) = boundary;
4670     }
4671
4672   /* Compute the rounded size of the type.  */
4673   type_size = size_in_bytes (type);
4674   rounded_size = round_up (type_size, align);
4675
4676   /* Reduce rounded_size so it's sharable with the postqueue.  */
4677   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4678
4679   /* Get AP.  */
4680   addr = valist_tmp;
4681   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4682     {
4683       /* Small args are padded downward.  */
4684       t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4685                        rounded_size, size_int (align));
4686       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4687                        size_binop (MINUS_EXPR, rounded_size, type_size));
4688       addr = fold_build2 (POINTER_PLUS_EXPR,
4689                           TREE_TYPE (addr), addr, t);
4690     }
4691
4692   /* Compute new value for AP.  */
4693   t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist), valist_tmp, rounded_size);
4694   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4695   gimplify_and_add (t, pre_p);
4696
4697   addr = fold_convert (build_pointer_type (type), addr);
4698
4699   if (indirect)
4700     addr = build_va_arg_indirect_ref (addr);
4701
4702   return build_va_arg_indirect_ref (addr);
4703 }
4704
4705 /* Build an indirect-ref expression over the given TREE, which represents a
4706    piece of a va_arg() expansion.  */
4707 tree
4708 build_va_arg_indirect_ref (tree addr)
4709 {
4710   addr = build_fold_indirect_ref_loc (EXPR_LOCATION (addr), addr);
4711
4712   if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF.  */
4713     mf_mark (addr);
4714
4715   return addr;
4716 }
4717
4718 /* Return a dummy expression of type TYPE in order to keep going after an
4719    error.  */
4720
4721 static tree
4722 dummy_object (tree type)
4723 {
4724   tree t = build_int_cst (build_pointer_type (type), 0);
4725   return build2 (MEM_REF, type, t, t);
4726 }
4727
4728 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4729    builtin function, but a very special sort of operator.  */
4730
4731 enum gimplify_status
4732 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4733 {
4734   tree promoted_type, have_va_type;
4735   tree valist = TREE_OPERAND (*expr_p, 0);
4736   tree type = TREE_TYPE (*expr_p);
4737   tree t;
4738   location_t loc = EXPR_LOCATION (*expr_p);
4739
4740   /* Verify that valist is of the proper type.  */
4741   have_va_type = TREE_TYPE (valist);
4742   if (have_va_type == error_mark_node)
4743     return GS_ERROR;
4744   have_va_type = targetm.canonical_va_list_type (have_va_type);
4745
4746   if (have_va_type == NULL_TREE)
4747     {
4748       error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4749       return GS_ERROR;
4750     }
4751
4752   /* Generate a diagnostic for requesting data of a type that cannot
4753      be passed through `...' due to type promotion at the call site.  */
4754   if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4755            != type)
4756     {
4757       static bool gave_help;
4758       bool warned;
4759
4760       /* Unfortunately, this is merely undefined, rather than a constraint
4761          violation, so we cannot make this an error.  If this call is never
4762          executed, the program is still strictly conforming.  */
4763       warned = warning_at (loc, 0,
4764                            "%qT is promoted to %qT when passed through %<...%>",
4765                            type, promoted_type);
4766       if (!gave_help && warned)
4767         {
4768           gave_help = true;
4769           inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4770                   promoted_type, type);
4771         }
4772
4773       /* We can, however, treat "undefined" any way we please.
4774          Call abort to encourage the user to fix the program.  */
4775       if (warned)
4776         inform (loc, "if this code is reached, the program will abort");
4777       /* Before the abort, allow the evaluation of the va_list
4778          expression to exit or longjmp.  */
4779       gimplify_and_add (valist, pre_p);
4780       t = build_call_expr_loc (loc,
4781                                implicit_built_in_decls[BUILT_IN_TRAP], 0);
4782       gimplify_and_add (t, pre_p);
4783
4784       /* This is dead code, but go ahead and finish so that the
4785          mode of the result comes out right.  */
4786       *expr_p = dummy_object (type);
4787       return GS_ALL_DONE;
4788     }
4789   else
4790     {
4791       /* Make it easier for the backends by protecting the valist argument
4792          from multiple evaluations.  */
4793       if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4794         {
4795           /* For this case, the backends will be expecting a pointer to
4796              TREE_TYPE (abi), but it's possible we've
4797              actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4798              So fix it.  */
4799           if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4800             {
4801               tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4802               valist = fold_convert_loc (loc, p1,
4803                                          build_fold_addr_expr_loc (loc, valist));
4804             }
4805
4806           gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4807         }
4808       else
4809         gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4810
4811       if (!targetm.gimplify_va_arg_expr)
4812         /* FIXME: Once most targets are converted we should merely
4813            assert this is non-null.  */
4814         return GS_ALL_DONE;
4815
4816       *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4817       return GS_OK;
4818     }
4819 }
4820
4821 /* Expand EXP, a call to __builtin_va_end.  */
4822
4823 static rtx
4824 expand_builtin_va_end (tree exp)
4825 {
4826   tree valist = CALL_EXPR_ARG (exp, 0);
4827
4828   /* Evaluate for side effects, if needed.  I hate macros that don't
4829      do that.  */
4830   if (TREE_SIDE_EFFECTS (valist))
4831     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4832
4833   return const0_rtx;
4834 }
4835
4836 /* Expand EXP, a call to __builtin_va_copy.  We do this as a
4837    builtin rather than just as an assignment in stdarg.h because of the
4838    nastiness of array-type va_list types.  */
4839
4840 static rtx
4841 expand_builtin_va_copy (tree exp)
4842 {
4843   tree dst, src, t;
4844   location_t loc = EXPR_LOCATION (exp);
4845
4846   dst = CALL_EXPR_ARG (exp, 0);
4847   src = CALL_EXPR_ARG (exp, 1);
4848
4849   dst = stabilize_va_list_loc (loc, dst, 1);
4850   src = stabilize_va_list_loc (loc, src, 0);
4851
4852   gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4853
4854   if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4855     {
4856       t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4857       TREE_SIDE_EFFECTS (t) = 1;
4858       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4859     }
4860   else
4861     {
4862       rtx dstb, srcb, size;
4863
4864       /* Evaluate to pointers.  */
4865       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4866       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4867       size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4868                   NULL_RTX, VOIDmode, EXPAND_NORMAL);
4869
4870       dstb = convert_memory_address (Pmode, dstb);
4871       srcb = convert_memory_address (Pmode, srcb);
4872
4873       /* "Dereference" to BLKmode memories.  */
4874       dstb = gen_rtx_MEM (BLKmode, dstb);
4875       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4876       set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4877       srcb = gen_rtx_MEM (BLKmode, srcb);
4878       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4879       set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4880
4881       /* Copy.  */
4882       emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4883     }
4884
4885   return const0_rtx;
4886 }
4887
4888 /* Expand a call to one of the builtin functions __builtin_frame_address or
4889    __builtin_return_address.  */
4890
4891 static rtx
4892 expand_builtin_frame_address (tree fndecl, tree exp)
4893 {
4894   /* The argument must be a nonnegative integer constant.
4895      It counts the number of frames to scan up the stack.
4896      The value is the return address saved in that frame.  */
4897   if (call_expr_nargs (exp) == 0)
4898     /* Warning about missing arg was already issued.  */
4899     return const0_rtx;
4900   else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4901     {
4902       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4903         error ("invalid argument to %<__builtin_frame_address%>");
4904       else
4905         error ("invalid argument to %<__builtin_return_address%>");
4906       return const0_rtx;
4907     }
4908   else
4909     {
4910       rtx tem
4911         = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4912                                       tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4913
4914       /* Some ports cannot access arbitrary stack frames.  */
4915       if (tem == NULL)
4916         {
4917           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4918             warning (0, "unsupported argument to %<__builtin_frame_address%>");
4919           else
4920             warning (0, "unsupported argument to %<__builtin_return_address%>");
4921           return const0_rtx;
4922         }
4923
4924       /* For __builtin_frame_address, return what we've got.  */
4925       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4926         return tem;
4927
4928       if (!REG_P (tem)
4929           && ! CONSTANT_P (tem))
4930         tem = copy_to_mode_reg (Pmode, tem);
4931       return tem;
4932     }
4933 }
4934
4935 /* Expand EXP, a call to the alloca builtin.  Return NULL_RTX if we
4936    failed and the caller should emit a normal call, otherwise try to
4937    get the result in TARGET, if convenient.  CANNOT_ACCUMULATE is the
4938    same as for allocate_dynamic_stack_space.  */
4939
4940 static rtx
4941 expand_builtin_alloca (tree exp, rtx target, bool cannot_accumulate)
4942 {
4943   rtx op0;
4944   rtx result;
4945
4946   /* Emit normal call if marked not-inlineable.  */
4947   if (CALL_CANNOT_INLINE_P (exp))
4948     return NULL_RTX;
4949
4950   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4951     return NULL_RTX;
4952
4953   /* Compute the argument.  */
4954   op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4955
4956   /* Allocate the desired space.  */
4957   result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT,
4958                                          cannot_accumulate);
4959   result = convert_memory_address (ptr_mode, result);
4960
4961   return result;
4962 }
4963
4964 /* Expand a call to a bswap builtin with argument ARG0.  MODE
4965    is the mode to expand with.  */
4966
4967 static rtx
4968 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
4969 {
4970   enum machine_mode mode;
4971   tree arg;
4972   rtx op0;
4973
4974   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4975     return NULL_RTX;
4976
4977   arg = CALL_EXPR_ARG (exp, 0);
4978   mode = TYPE_MODE (TREE_TYPE (arg));
4979   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4980
4981   target = expand_unop (mode, bswap_optab, op0, target, 1);
4982
4983   gcc_assert (target);
4984
4985   return convert_to_mode (mode, target, 0);
4986 }
4987
4988 /* Expand a call to a unary builtin in EXP.
4989    Return NULL_RTX if a normal call should be emitted rather than expanding the
4990    function in-line.  If convenient, the result should be placed in TARGET.
4991    SUBTARGET may be used as the target for computing one of EXP's operands.  */
4992
4993 static rtx
4994 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
4995                      rtx subtarget, optab op_optab)
4996 {
4997   rtx op0;
4998
4999   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5000     return NULL_RTX;
5001
5002   /* Compute the argument.  */
5003   op0 = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
5004                      VOIDmode, EXPAND_NORMAL);
5005   /* Compute op, into TARGET if possible.
5006      Set TARGET to wherever the result comes back.  */
5007   target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
5008                         op_optab, op0, target, 1);
5009   gcc_assert (target);
5010
5011   return convert_to_mode (target_mode, target, 0);
5012 }
5013
5014 /* Expand a call to __builtin_expect.  We just return our argument
5015    as the builtin_expect semantic should've been already executed by
5016    tree branch prediction pass. */
5017
5018 static rtx
5019 expand_builtin_expect (tree exp, rtx target)
5020 {
5021   tree arg;
5022
5023   if (call_expr_nargs (exp) < 2)
5024     return const0_rtx;
5025   arg = CALL_EXPR_ARG (exp, 0);
5026
5027   target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5028   /* When guessing was done, the hints should be already stripped away.  */
5029   gcc_assert (!flag_guess_branch_prob
5030               || optimize == 0 || seen_error ());
5031   return target;
5032 }
5033
5034 void
5035 expand_builtin_trap (void)
5036 {
5037 #ifdef HAVE_trap
5038   if (HAVE_trap)
5039     emit_insn (gen_trap ());
5040   else
5041 #endif
5042     emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
5043   emit_barrier ();
5044 }
5045
5046 /* Expand a call to __builtin_unreachable.  We do nothing except emit
5047    a barrier saying that control flow will not pass here.
5048
5049    It is the responsibility of the program being compiled to ensure
5050    that control flow does never reach __builtin_unreachable.  */
5051 static void
5052 expand_builtin_unreachable (void)
5053 {
5054   emit_barrier ();
5055 }
5056
5057 /* Expand EXP, a call to fabs, fabsf or fabsl.
5058    Return NULL_RTX if a normal call should be emitted rather than expanding
5059    the function inline.  If convenient, the result should be placed
5060    in TARGET.  SUBTARGET may be used as the target for computing
5061    the operand.  */
5062
5063 static rtx
5064 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
5065 {
5066   enum machine_mode mode;
5067   tree arg;
5068   rtx op0;
5069
5070   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5071     return NULL_RTX;
5072
5073   arg = CALL_EXPR_ARG (exp, 0);
5074   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
5075   mode = TYPE_MODE (TREE_TYPE (arg));
5076   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5077   return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
5078 }
5079
5080 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5081    Return NULL is a normal call should be emitted rather than expanding the
5082    function inline.  If convenient, the result should be placed in TARGET.
5083    SUBTARGET may be used as the target for computing the operand.  */
5084
5085 static rtx
5086 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
5087 {
5088   rtx op0, op1;
5089   tree arg;
5090
5091   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
5092     return NULL_RTX;
5093
5094   arg = CALL_EXPR_ARG (exp, 0);
5095   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5096
5097   arg = CALL_EXPR_ARG (exp, 1);
5098   op1 = expand_normal (arg);
5099
5100   return expand_copysign (op0, op1, target);
5101 }
5102
5103 /* Create a new constant string literal and return a char* pointer to it.
5104    The STRING_CST value is the LEN characters at STR.  */
5105 tree
5106 build_string_literal (int len, const char *str)
5107 {
5108   tree t, elem, index, type;
5109
5110   t = build_string (len, str);
5111   elem = build_type_variant (char_type_node, 1, 0);
5112   index = build_index_type (size_int (len - 1));
5113   type = build_array_type (elem, index);
5114   TREE_TYPE (t) = type;
5115   TREE_CONSTANT (t) = 1;
5116   TREE_READONLY (t) = 1;
5117   TREE_STATIC (t) = 1;
5118
5119   type = build_pointer_type (elem);
5120   t = build1 (ADDR_EXPR, type,
5121               build4 (ARRAY_REF, elem,
5122                       t, integer_zero_node, NULL_TREE, NULL_TREE));
5123   return t;
5124 }
5125
5126 /* Expand a call to either the entry or exit function profiler.  */
5127
5128 static rtx
5129 expand_builtin_profile_func (bool exitp)
5130 {
5131   rtx this_rtx, which;
5132
5133   this_rtx = DECL_RTL (current_function_decl);
5134   gcc_assert (MEM_P (this_rtx));
5135   this_rtx = XEXP (this_rtx, 0);
5136
5137   if (exitp)
5138     which = profile_function_exit_libfunc;
5139   else
5140     which = profile_function_entry_libfunc;
5141
5142   emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this_rtx, Pmode,
5143                      expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5144                                                  0),
5145                      Pmode);
5146
5147   return const0_rtx;
5148 }
5149
5150 /* Expand a call to __builtin___clear_cache.  */
5151
5152 static rtx
5153 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
5154 {
5155 #ifndef HAVE_clear_cache
5156 #ifdef CLEAR_INSN_CACHE
5157   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5158      does something.  Just do the default expansion to a call to
5159      __clear_cache().  */
5160   return NULL_RTX;
5161 #else
5162   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5163      does nothing.  There is no need to call it.  Do nothing.  */
5164   return const0_rtx;
5165 #endif /* CLEAR_INSN_CACHE */
5166 #else
5167   /* We have a "clear_cache" insn, and it will handle everything.  */
5168   tree begin, end;
5169   rtx begin_rtx, end_rtx;
5170   enum insn_code icode;
5171
5172   /* We must not expand to a library call.  If we did, any
5173      fallback library function in libgcc that might contain a call to
5174      __builtin___clear_cache() would recurse infinitely.  */
5175   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5176     {
5177       error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5178       return const0_rtx;
5179     }
5180
5181   if (HAVE_clear_cache)
5182     {
5183       icode = CODE_FOR_clear_cache;
5184
5185       begin = CALL_EXPR_ARG (exp, 0);
5186       begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
5187       begin_rtx = convert_memory_address (Pmode, begin_rtx);
5188       if (!insn_data[icode].operand[0].predicate (begin_rtx, Pmode))
5189         begin_rtx = copy_to_mode_reg (Pmode, begin_rtx);
5190
5191       end = CALL_EXPR_ARG (exp, 1);
5192       end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
5193       end_rtx = convert_memory_address (Pmode, end_rtx);
5194       if (!insn_data[icode].operand[1].predicate (end_rtx, Pmode))
5195         end_rtx = copy_to_mode_reg (Pmode, end_rtx);
5196
5197       emit_insn (gen_clear_cache (begin_rtx, end_rtx));
5198     }
5199   return const0_rtx;
5200 #endif /* HAVE_clear_cache */
5201 }
5202
5203 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT.  */
5204
5205 static rtx
5206 round_trampoline_addr (rtx tramp)
5207 {
5208   rtx temp, addend, mask;
5209
5210   /* If we don't need too much alignment, we'll have been guaranteed
5211      proper alignment by get_trampoline_type.  */
5212   if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5213     return tramp;
5214
5215   /* Round address up to desired boundary.  */
5216   temp = gen_reg_rtx (Pmode);
5217   addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5218   mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5219
5220   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5221                                temp, 0, OPTAB_LIB_WIDEN);
5222   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5223                                temp, 0, OPTAB_LIB_WIDEN);
5224
5225   return tramp;
5226 }
5227
5228 static rtx
5229 expand_builtin_init_trampoline (tree exp)
5230 {
5231   tree t_tramp, t_func, t_chain;
5232   rtx m_tramp, r_tramp, r_chain, tmp;
5233
5234   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5235                          POINTER_TYPE, VOID_TYPE))
5236     return NULL_RTX;
5237
5238   t_tramp = CALL_EXPR_ARG (exp, 0);
5239   t_func = CALL_EXPR_ARG (exp, 1);
5240   t_chain = CALL_EXPR_ARG (exp, 2);
5241
5242   r_tramp = expand_normal (t_tramp);
5243   m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
5244   MEM_NOTRAP_P (m_tramp) = 1;
5245
5246   /* The TRAMP argument should be the address of a field within the
5247      local function's FRAME decl.  Let's see if we can fill in the
5248      to fill in the MEM_ATTRs for this memory.  */
5249   if (TREE_CODE (t_tramp) == ADDR_EXPR)
5250     set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
5251                                      true, 0);
5252
5253   tmp = round_trampoline_addr (r_tramp);
5254   if (tmp != r_tramp)
5255     {
5256       m_tramp = change_address (m_tramp, BLKmode, tmp);
5257       set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
5258       set_mem_size (m_tramp, GEN_INT (TRAMPOLINE_SIZE));
5259     }
5260
5261   /* The FUNC argument should be the address of the nested function.
5262      Extract the actual function decl to pass to the hook.  */
5263   gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
5264   t_func = TREE_OPERAND (t_func, 0);
5265   gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
5266
5267   r_chain = expand_normal (t_chain);
5268
5269   /* Generate insns to initialize the trampoline.  */
5270   targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
5271
5272   trampolines_created = 1;
5273
5274   warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
5275               "trampoline generated for nested function %qD", t_func);
5276
5277   return const0_rtx;
5278 }
5279
5280 static rtx
5281 expand_builtin_adjust_trampoline (tree exp)
5282 {
5283   rtx tramp;
5284
5285   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5286     return NULL_RTX;
5287
5288   tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5289   tramp = round_trampoline_addr (tramp);
5290   if (targetm.calls.trampoline_adjust_address)
5291     tramp = targetm.calls.trampoline_adjust_address (tramp);
5292
5293   return tramp;
5294 }
5295
5296 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5297    function.  The function first checks whether the back end provides
5298    an insn to implement signbit for the respective mode.  If not, it
5299    checks whether the floating point format of the value is such that
5300    the sign bit can be extracted.  If that is not the case, the
5301    function returns NULL_RTX to indicate that a normal call should be
5302    emitted rather than expanding the function in-line.  EXP is the
5303    expression that is a call to the builtin function; if convenient,
5304    the result should be placed in TARGET.  */
5305 static rtx
5306 expand_builtin_signbit (tree exp, rtx target)
5307 {
5308   const struct real_format *fmt;
5309   enum machine_mode fmode, imode, rmode;
5310   tree arg;
5311   int word, bitpos;
5312   enum insn_code icode;
5313   rtx temp;
5314   location_t loc = EXPR_LOCATION (exp);
5315
5316   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5317     return NULL_RTX;
5318
5319   arg = CALL_EXPR_ARG (exp, 0);
5320   fmode = TYPE_MODE (TREE_TYPE (arg));
5321   rmode = TYPE_MODE (TREE_TYPE (exp));
5322   fmt = REAL_MODE_FORMAT (fmode);
5323
5324   arg = builtin_save_expr (arg);
5325
5326   /* Expand the argument yielding a RTX expression. */
5327   temp = expand_normal (arg);
5328
5329   /* Check if the back end provides an insn that handles signbit for the
5330      argument's mode. */
5331   icode = optab_handler (signbit_optab, fmode);
5332   if (icode != CODE_FOR_nothing)
5333     {
5334       rtx last = get_last_insn ();
5335       target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5336       if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
5337         return target;
5338       delete_insns_since (last);
5339     }
5340
5341   /* For floating point formats without a sign bit, implement signbit
5342      as "ARG < 0.0".  */
5343   bitpos = fmt->signbit_ro;
5344   if (bitpos < 0)
5345   {
5346     /* But we can't do this if the format supports signed zero.  */
5347     if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5348       return NULL_RTX;
5349
5350     arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5351                        build_real (TREE_TYPE (arg), dconst0));
5352     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5353   }
5354
5355   if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5356     {
5357       imode = int_mode_for_mode (fmode);
5358       if (imode == BLKmode)
5359         return NULL_RTX;
5360       temp = gen_lowpart (imode, temp);
5361     }
5362   else
5363     {
5364       imode = word_mode;
5365       /* Handle targets with different FP word orders.  */
5366       if (FLOAT_WORDS_BIG_ENDIAN)
5367         word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5368       else
5369         word = bitpos / BITS_PER_WORD;
5370       temp = operand_subword_force (temp, word, fmode);
5371       bitpos = bitpos % BITS_PER_WORD;
5372     }
5373
5374   /* Force the intermediate word_mode (or narrower) result into a
5375      register.  This avoids attempting to create paradoxical SUBREGs
5376      of floating point modes below.  */
5377   temp = force_reg (imode, temp);
5378
5379   /* If the bitpos is within the "result mode" lowpart, the operation
5380      can be implement with a single bitwise AND.  Otherwise, we need
5381      a right shift and an AND.  */
5382
5383   if (bitpos < GET_MODE_BITSIZE (rmode))
5384     {
5385       double_int mask = double_int_setbit (double_int_zero, bitpos);
5386
5387       if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5388         temp = gen_lowpart (rmode, temp);
5389       temp = expand_binop (rmode, and_optab, temp,
5390                            immed_double_int_const (mask, rmode),
5391                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5392     }
5393   else
5394     {
5395       /* Perform a logical right shift to place the signbit in the least
5396          significant bit, then truncate the result to the desired mode
5397          and mask just this bit.  */
5398       temp = expand_shift (RSHIFT_EXPR, imode, temp,
5399                            build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5400       temp = gen_lowpart (rmode, temp);
5401       temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5402                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5403     }
5404
5405   return temp;
5406 }
5407
5408 /* Expand fork or exec calls.  TARGET is the desired target of the
5409    call.  EXP is the call. FN is the
5410    identificator of the actual function.  IGNORE is nonzero if the
5411    value is to be ignored.  */
5412
5413 static rtx
5414 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5415 {
5416   tree id, decl;
5417   tree call;
5418
5419   /* If we are not profiling, just call the function.  */
5420   if (!profile_arc_flag)
5421     return NULL_RTX;
5422
5423   /* Otherwise call the wrapper.  This should be equivalent for the rest of
5424      compiler, so the code does not diverge, and the wrapper may run the
5425      code necessary for keeping the profiling sane.  */
5426
5427   switch (DECL_FUNCTION_CODE (fn))
5428     {
5429     case BUILT_IN_FORK:
5430       id = get_identifier ("__gcov_fork");
5431       break;
5432
5433     case BUILT_IN_EXECL:
5434       id = get_identifier ("__gcov_execl");
5435       break;
5436
5437     case BUILT_IN_EXECV:
5438       id = get_identifier ("__gcov_execv");
5439       break;
5440
5441     case BUILT_IN_EXECLP:
5442       id = get_identifier ("__gcov_execlp");
5443       break;
5444
5445     case BUILT_IN_EXECLE:
5446       id = get_identifier ("__gcov_execle");
5447       break;
5448
5449     case BUILT_IN_EXECVP:
5450       id = get_identifier ("__gcov_execvp");
5451       break;
5452
5453     case BUILT_IN_EXECVE:
5454       id = get_identifier ("__gcov_execve");
5455       break;
5456
5457     default:
5458       gcc_unreachable ();
5459     }
5460
5461   decl = build_decl (DECL_SOURCE_LOCATION (fn),
5462                      FUNCTION_DECL, id, TREE_TYPE (fn));
5463   DECL_EXTERNAL (decl) = 1;
5464   TREE_PUBLIC (decl) = 1;
5465   DECL_ARTIFICIAL (decl) = 1;
5466   TREE_NOTHROW (decl) = 1;
5467   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5468   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5469   call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5470   return expand_call (call, target, ignore);
5471  }
5472
5473
5474 \f
5475 /* Reconstitute a mode for a __sync intrinsic operation.  Since the type of
5476    the pointer in these functions is void*, the tree optimizers may remove
5477    casts.  The mode computed in expand_builtin isn't reliable either, due
5478    to __sync_bool_compare_and_swap.
5479
5480    FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5481    group of builtins.  This gives us log2 of the mode size.  */
5482
5483 static inline enum machine_mode
5484 get_builtin_sync_mode (int fcode_diff)
5485 {
5486   /* The size is not negotiable, so ask not to get BLKmode in return
5487      if the target indicates that a smaller size would be better.  */
5488   return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5489 }
5490
5491 /* Expand the memory expression LOC and return the appropriate memory operand
5492    for the builtin_sync operations.  */
5493
5494 static rtx
5495 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5496 {
5497   rtx addr, mem;
5498
5499   addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
5500   addr = convert_memory_address (Pmode, addr);
5501
5502   /* Note that we explicitly do not want any alias information for this
5503      memory, so that we kill all other live memories.  Otherwise we don't
5504      satisfy the full barrier semantics of the intrinsic.  */
5505   mem = validize_mem (gen_rtx_MEM (mode, addr));
5506
5507   /* The alignment needs to be at least according to that of the mode.  */
5508   set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
5509                            get_pointer_alignment (loc, BIGGEST_ALIGNMENT)));
5510   set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5511   MEM_VOLATILE_P (mem) = 1;
5512
5513   return mem;
5514 }
5515
5516 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5517    EXP is the CALL_EXPR.  CODE is the rtx code
5518    that corresponds to the arithmetic or logical operation from the name;
5519    an exception here is that NOT actually means NAND.  TARGET is an optional
5520    place for us to store the results; AFTER is true if this is the
5521    fetch_and_xxx form.  IGNORE is true if we don't actually care about
5522    the result of the operation at all.  */
5523
5524 static rtx
5525 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5526                                enum rtx_code code, bool after,
5527                                rtx target, bool ignore)
5528 {
5529   rtx val, mem;
5530   enum machine_mode old_mode;
5531   location_t loc = EXPR_LOCATION (exp);
5532
5533   if (code == NOT && warn_sync_nand)
5534     {
5535       tree fndecl = get_callee_fndecl (exp);
5536       enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5537
5538       static bool warned_f_a_n, warned_n_a_f;
5539
5540       switch (fcode)
5541         {
5542         case BUILT_IN_FETCH_AND_NAND_1:
5543         case BUILT_IN_FETCH_AND_NAND_2:
5544         case BUILT_IN_FETCH_AND_NAND_4:
5545         case BUILT_IN_FETCH_AND_NAND_8:
5546         case BUILT_IN_FETCH_AND_NAND_16:
5547
5548           if (warned_f_a_n)
5549             break;
5550
5551           fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
5552           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5553           warned_f_a_n = true;
5554           break;
5555
5556         case BUILT_IN_NAND_AND_FETCH_1:
5557         case BUILT_IN_NAND_AND_FETCH_2:
5558         case BUILT_IN_NAND_AND_FETCH_4:
5559         case BUILT_IN_NAND_AND_FETCH_8:
5560         case BUILT_IN_NAND_AND_FETCH_16:
5561
5562           if (warned_n_a_f)
5563             break;
5564
5565           fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
5566           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5567           warned_n_a_f = true;
5568           break;
5569
5570         default:
5571           gcc_unreachable ();
5572         }
5573     }
5574
5575   /* Expand the operands.  */
5576   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5577
5578   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5579   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5580      of CONST_INTs, where we know the old_mode only from the call argument.  */
5581   old_mode = GET_MODE (val);
5582   if (old_mode == VOIDmode)
5583     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5584   val = convert_modes (mode, old_mode, val, 1);
5585
5586   if (ignore)
5587     return expand_sync_operation (mem, val, code);
5588   else
5589     return expand_sync_fetch_operation (mem, val, code, after, target);
5590 }
5591
5592 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5593    intrinsics. EXP is the CALL_EXPR.  IS_BOOL is
5594    true if this is the boolean form.  TARGET is a place for us to store the
5595    results; this is NOT optional if IS_BOOL is true.  */
5596
5597 static rtx
5598 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5599                                  bool is_bool, rtx target)
5600 {
5601   rtx old_val, new_val, mem;
5602   enum machine_mode old_mode;
5603
5604   /* Expand the operands.  */
5605   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5606
5607
5608   old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX,
5609                          mode, EXPAND_NORMAL);
5610   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5611      of CONST_INTs, where we know the old_mode only from the call argument.  */
5612   old_mode = GET_MODE (old_val);
5613   if (old_mode == VOIDmode)
5614     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5615   old_val = convert_modes (mode, old_mode, old_val, 1);
5616
5617   new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL_RTX,
5618                          mode, EXPAND_NORMAL);
5619   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5620      of CONST_INTs, where we know the old_mode only from the call argument.  */
5621   old_mode = GET_MODE (new_val);
5622   if (old_mode == VOIDmode)
5623     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2)));
5624   new_val = convert_modes (mode, old_mode, new_val, 1);
5625
5626   if (is_bool)
5627     return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5628   else
5629     return expand_val_compare_and_swap (mem, old_val, new_val, target);
5630 }
5631
5632 /* Expand the __sync_lock_test_and_set intrinsic.  Note that the most
5633    general form is actually an atomic exchange, and some targets only
5634    support a reduced form with the second argument being a constant 1.
5635    EXP is the CALL_EXPR; TARGET is an optional place for us to store
5636    the results.  */
5637
5638 static rtx
5639 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
5640                                   rtx target)
5641 {
5642   rtx val, mem;
5643   enum machine_mode old_mode;
5644
5645   /* Expand the operands.  */
5646   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5647   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5648   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5649      of CONST_INTs, where we know the old_mode only from the call argument.  */
5650   old_mode = GET_MODE (val);
5651   if (old_mode == VOIDmode)
5652     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5653   val = convert_modes (mode, old_mode, val, 1);
5654
5655   return expand_sync_lock_test_and_set (mem, val, target);
5656 }
5657
5658 /* Expand the __sync_synchronize intrinsic.  */
5659
5660 static void
5661 expand_builtin_synchronize (void)
5662 {
5663   gimple x;
5664   VEC (tree, gc) *v_clobbers;
5665
5666 #ifdef HAVE_memory_barrier
5667   if (HAVE_memory_barrier)
5668     {
5669       emit_insn (gen_memory_barrier ());
5670       return;
5671     }
5672 #endif
5673
5674   if (synchronize_libfunc != NULL_RTX)
5675     {
5676       emit_library_call (synchronize_libfunc, LCT_NORMAL, VOIDmode, 0);
5677       return;
5678     }
5679
5680   /* If no explicit memory barrier instruction is available, create an
5681      empty asm stmt with a memory clobber.  */
5682   v_clobbers = VEC_alloc (tree, gc, 1);
5683   VEC_quick_push (tree, v_clobbers,
5684                   tree_cons (NULL, build_string (6, "memory"), NULL));
5685   x = gimple_build_asm_vec ("", NULL, NULL, v_clobbers, NULL);
5686   gimple_asm_set_volatile (x, true);
5687   expand_asm_stmt (x);
5688 }
5689
5690 /* Expand the __sync_lock_release intrinsic.  EXP is the CALL_EXPR.  */
5691
5692 static void
5693 expand_builtin_lock_release (enum machine_mode mode, tree exp)
5694 {
5695   enum insn_code icode;
5696   rtx mem, insn;
5697   rtx val = const0_rtx;
5698
5699   /* Expand the operands.  */
5700   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5701
5702   /* If there is an explicit operation in the md file, use it.  */
5703   icode = direct_optab_handler (sync_lock_release_optab, mode);
5704   if (icode != CODE_FOR_nothing)
5705     {
5706       if (!insn_data[icode].operand[1].predicate (val, mode))
5707         val = force_reg (mode, val);
5708
5709       insn = GEN_FCN (icode) (mem, val);
5710       if (insn)
5711         {
5712           emit_insn (insn);
5713           return;
5714         }
5715     }
5716
5717   /* Otherwise we can implement this operation by emitting a barrier
5718      followed by a store of zero.  */
5719   expand_builtin_synchronize ();
5720   emit_move_insn (mem, val);
5721 }
5722 \f
5723 /* Expand an expression EXP that calls a built-in function,
5724    with result going to TARGET if that's convenient
5725    (and in mode MODE if that's convenient).
5726    SUBTARGET may be used as the target for computing one of EXP's operands.
5727    IGNORE is nonzero if the value is to be ignored.  */
5728
5729 rtx
5730 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5731                 int ignore)
5732 {
5733   tree fndecl = get_callee_fndecl (exp);
5734   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5735   enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5736   int flags;
5737
5738   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5739     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5740
5741   /* When not optimizing, generate calls to library functions for a certain
5742      set of builtins.  */
5743   if (!optimize
5744       && !called_as_built_in (fndecl)
5745       && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5746       && fcode != BUILT_IN_ALLOCA
5747       && fcode != BUILT_IN_FREE)
5748     return expand_call (exp, target, ignore);
5749
5750   /* The built-in function expanders test for target == const0_rtx
5751      to determine whether the function's result will be ignored.  */
5752   if (ignore)
5753     target = const0_rtx;
5754
5755   /* If the result of a pure or const built-in function is ignored, and
5756      none of its arguments are volatile, we can avoid expanding the
5757      built-in call and just evaluate the arguments for side-effects.  */
5758   if (target == const0_rtx
5759       && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5760       && !(flags & ECF_LOOPING_CONST_OR_PURE))
5761     {
5762       bool volatilep = false;
5763       tree arg;
5764       call_expr_arg_iterator iter;
5765
5766       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5767         if (TREE_THIS_VOLATILE (arg))
5768           {
5769             volatilep = true;
5770             break;
5771           }
5772
5773       if (! volatilep)
5774         {
5775           FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5776             expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5777           return const0_rtx;
5778         }
5779     }
5780
5781   switch (fcode)
5782     {
5783     CASE_FLT_FN (BUILT_IN_FABS):
5784       target = expand_builtin_fabs (exp, target, subtarget);
5785       if (target)
5786         return target;
5787       break;
5788
5789     CASE_FLT_FN (BUILT_IN_COPYSIGN):
5790       target = expand_builtin_copysign (exp, target, subtarget);
5791       if (target)
5792         return target;
5793       break;
5794
5795       /* Just do a normal library call if we were unable to fold
5796          the values.  */
5797     CASE_FLT_FN (BUILT_IN_CABS):
5798       break;
5799
5800     CASE_FLT_FN (BUILT_IN_EXP):
5801     CASE_FLT_FN (BUILT_IN_EXP10):
5802     CASE_FLT_FN (BUILT_IN_POW10):
5803     CASE_FLT_FN (BUILT_IN_EXP2):
5804     CASE_FLT_FN (BUILT_IN_EXPM1):
5805     CASE_FLT_FN (BUILT_IN_LOGB):
5806     CASE_FLT_FN (BUILT_IN_LOG):
5807     CASE_FLT_FN (BUILT_IN_LOG10):
5808     CASE_FLT_FN (BUILT_IN_LOG2):
5809     CASE_FLT_FN (BUILT_IN_LOG1P):
5810     CASE_FLT_FN (BUILT_IN_TAN):
5811     CASE_FLT_FN (BUILT_IN_ASIN):
5812     CASE_FLT_FN (BUILT_IN_ACOS):
5813     CASE_FLT_FN (BUILT_IN_ATAN):
5814     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5815       /* Treat these like sqrt only if unsafe math optimizations are allowed,
5816          because of possible accuracy problems.  */
5817       if (! flag_unsafe_math_optimizations)
5818         break;
5819     CASE_FLT_FN (BUILT_IN_SQRT):
5820     CASE_FLT_FN (BUILT_IN_FLOOR):
5821     CASE_FLT_FN (BUILT_IN_CEIL):
5822     CASE_FLT_FN (BUILT_IN_TRUNC):
5823     CASE_FLT_FN (BUILT_IN_ROUND):
5824     CASE_FLT_FN (BUILT_IN_NEARBYINT):
5825     CASE_FLT_FN (BUILT_IN_RINT):
5826       target = expand_builtin_mathfn (exp, target, subtarget);
5827       if (target)
5828         return target;
5829       break;
5830
5831     CASE_FLT_FN (BUILT_IN_ILOGB):
5832       if (! flag_unsafe_math_optimizations)
5833         break;
5834     CASE_FLT_FN (BUILT_IN_ISINF):
5835     CASE_FLT_FN (BUILT_IN_FINITE):
5836     case BUILT_IN_ISFINITE:
5837     case BUILT_IN_ISNORMAL:
5838       target = expand_builtin_interclass_mathfn (exp, target, subtarget);
5839       if (target)
5840         return target;
5841       break;
5842
5843     CASE_FLT_FN (BUILT_IN_LCEIL):
5844     CASE_FLT_FN (BUILT_IN_LLCEIL):
5845     CASE_FLT_FN (BUILT_IN_LFLOOR):
5846     CASE_FLT_FN (BUILT_IN_LLFLOOR):
5847       target = expand_builtin_int_roundingfn (exp, target);
5848       if (target)
5849         return target;
5850       break;
5851
5852     CASE_FLT_FN (BUILT_IN_LRINT):
5853     CASE_FLT_FN (BUILT_IN_LLRINT):
5854     CASE_FLT_FN (BUILT_IN_LROUND):
5855     CASE_FLT_FN (BUILT_IN_LLROUND):
5856       target = expand_builtin_int_roundingfn_2 (exp, target);
5857       if (target)
5858         return target;
5859       break;
5860
5861     CASE_FLT_FN (BUILT_IN_POW):
5862       target = expand_builtin_pow (exp, target, subtarget);
5863       if (target)
5864         return target;
5865       break;
5866
5867     CASE_FLT_FN (BUILT_IN_POWI):
5868       target = expand_builtin_powi (exp, target, subtarget);
5869       if (target)
5870         return target;
5871       break;
5872
5873     CASE_FLT_FN (BUILT_IN_ATAN2):
5874     CASE_FLT_FN (BUILT_IN_LDEXP):
5875     CASE_FLT_FN (BUILT_IN_SCALB):
5876     CASE_FLT_FN (BUILT_IN_SCALBN):
5877     CASE_FLT_FN (BUILT_IN_SCALBLN):
5878       if (! flag_unsafe_math_optimizations)
5879         break;
5880
5881     CASE_FLT_FN (BUILT_IN_FMOD):
5882     CASE_FLT_FN (BUILT_IN_REMAINDER):
5883     CASE_FLT_FN (BUILT_IN_DREM):
5884       target = expand_builtin_mathfn_2 (exp, target, subtarget);
5885       if (target)
5886         return target;
5887       break;
5888
5889     CASE_FLT_FN (BUILT_IN_CEXPI):
5890       target = expand_builtin_cexpi (exp, target, subtarget);
5891       gcc_assert (target);
5892       return target;
5893
5894     CASE_FLT_FN (BUILT_IN_SIN):
5895     CASE_FLT_FN (BUILT_IN_COS):
5896       if (! flag_unsafe_math_optimizations)
5897         break;
5898       target = expand_builtin_mathfn_3 (exp, target, subtarget);
5899       if (target)
5900         return target;
5901       break;
5902
5903     CASE_FLT_FN (BUILT_IN_SINCOS):
5904       if (! flag_unsafe_math_optimizations)
5905         break;
5906       target = expand_builtin_sincos (exp);
5907       if (target)
5908         return target;
5909       break;
5910
5911     case BUILT_IN_APPLY_ARGS:
5912       return expand_builtin_apply_args ();
5913
5914       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5915          FUNCTION with a copy of the parameters described by
5916          ARGUMENTS, and ARGSIZE.  It returns a block of memory
5917          allocated on the stack into which is stored all the registers
5918          that might possibly be used for returning the result of a
5919          function.  ARGUMENTS is the value returned by
5920          __builtin_apply_args.  ARGSIZE is the number of bytes of
5921          arguments that must be copied.  ??? How should this value be
5922          computed?  We'll also need a safe worst case value for varargs
5923          functions.  */
5924     case BUILT_IN_APPLY:
5925       if (!validate_arglist (exp, POINTER_TYPE,
5926                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5927           && !validate_arglist (exp, REFERENCE_TYPE,
5928                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5929         return const0_rtx;
5930       else
5931         {
5932           rtx ops[3];
5933
5934           ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
5935           ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
5936           ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
5937
5938           return expand_builtin_apply (ops[0], ops[1], ops[2]);
5939         }
5940
5941       /* __builtin_return (RESULT) causes the function to return the
5942          value described by RESULT.  RESULT is address of the block of
5943          memory returned by __builtin_apply.  */
5944     case BUILT_IN_RETURN:
5945       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5946         expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
5947       return const0_rtx;
5948
5949     case BUILT_IN_SAVEREGS:
5950       return expand_builtin_saveregs ();
5951
5952     case BUILT_IN_VA_ARG_PACK:
5953       /* All valid uses of __builtin_va_arg_pack () are removed during
5954          inlining.  */
5955       error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
5956       return const0_rtx;
5957
5958     case BUILT_IN_VA_ARG_PACK_LEN:
5959       /* All valid uses of __builtin_va_arg_pack_len () are removed during
5960          inlining.  */
5961       error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
5962       return const0_rtx;
5963
5964       /* Return the address of the first anonymous stack arg.  */
5965     case BUILT_IN_NEXT_ARG:
5966       if (fold_builtin_next_arg (exp, false))
5967         return const0_rtx;
5968       return expand_builtin_next_arg ();
5969
5970     case BUILT_IN_CLEAR_CACHE:
5971       target = expand_builtin___clear_cache (exp);
5972       if (target)
5973         return target;
5974       break;
5975
5976     case BUILT_IN_CLASSIFY_TYPE:
5977       return expand_builtin_classify_type (exp);
5978
5979     case BUILT_IN_CONSTANT_P:
5980       return const0_rtx;
5981
5982     case BUILT_IN_FRAME_ADDRESS:
5983     case BUILT_IN_RETURN_ADDRESS:
5984       return expand_builtin_frame_address (fndecl, exp);
5985
5986     /* Returns the address of the area where the structure is returned.
5987        0 otherwise.  */
5988     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
5989       if (call_expr_nargs (exp) != 0
5990           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
5991           || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
5992         return const0_rtx;
5993       else
5994         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
5995
5996     case BUILT_IN_ALLOCA:
5997       /* If the allocation stems from the declaration of a variable-sized
5998          object, it cannot accumulate.  */
5999       target = expand_builtin_alloca (exp, target, ALLOCA_FOR_VAR_P (exp));
6000       if (target)
6001         return target;
6002       break;
6003
6004     case BUILT_IN_STACK_SAVE:
6005       return expand_stack_save ();
6006
6007     case BUILT_IN_STACK_RESTORE:
6008       expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6009       return const0_rtx;
6010
6011     case BUILT_IN_BSWAP32:
6012     case BUILT_IN_BSWAP64:
6013       target = expand_builtin_bswap (exp, target, subtarget);
6014
6015       if (target)
6016         return target;
6017       break;
6018
6019     CASE_INT_FN (BUILT_IN_FFS):
6020     case BUILT_IN_FFSIMAX:
6021       target = expand_builtin_unop (target_mode, exp, target,
6022                                     subtarget, ffs_optab);
6023       if (target)
6024         return target;
6025       break;
6026
6027     CASE_INT_FN (BUILT_IN_CLZ):
6028     case BUILT_IN_CLZIMAX:
6029       target = expand_builtin_unop (target_mode, exp, target,
6030                                     subtarget, clz_optab);
6031       if (target)
6032         return target;
6033       break;
6034
6035     CASE_INT_FN (BUILT_IN_CTZ):
6036     case BUILT_IN_CTZIMAX:
6037       target = expand_builtin_unop (target_mode, exp, target,
6038                                     subtarget, ctz_optab);
6039       if (target)
6040         return target;
6041       break;
6042
6043     CASE_INT_FN (BUILT_IN_POPCOUNT):
6044     case BUILT_IN_POPCOUNTIMAX:
6045       target = expand_builtin_unop (target_mode, exp, target,
6046                                     subtarget, popcount_optab);
6047       if (target)
6048         return target;
6049       break;
6050
6051     CASE_INT_FN (BUILT_IN_PARITY):
6052     case BUILT_IN_PARITYIMAX:
6053       target = expand_builtin_unop (target_mode, exp, target,
6054                                     subtarget, parity_optab);
6055       if (target)
6056         return target;
6057       break;
6058
6059     case BUILT_IN_STRLEN:
6060       target = expand_builtin_strlen (exp, target, target_mode);
6061       if (target)
6062         return target;
6063       break;
6064
6065     case BUILT_IN_STRCPY:
6066       target = expand_builtin_strcpy (exp, target);
6067       if (target)
6068         return target;
6069       break;
6070
6071     case BUILT_IN_STRNCPY:
6072       target = expand_builtin_strncpy (exp, target);
6073       if (target)
6074         return target;
6075       break;
6076
6077     case BUILT_IN_STPCPY:
6078       target = expand_builtin_stpcpy (exp, target, mode);
6079       if (target)
6080         return target;
6081       break;
6082
6083     case BUILT_IN_MEMCPY:
6084       target = expand_builtin_memcpy (exp, target);
6085       if (target)
6086         return target;
6087       break;
6088
6089     case BUILT_IN_MEMPCPY:
6090       target = expand_builtin_mempcpy (exp, target, mode);
6091       if (target)
6092         return target;
6093       break;
6094
6095     case BUILT_IN_MEMSET:
6096       target = expand_builtin_memset (exp, target, mode);
6097       if (target)
6098         return target;
6099       break;
6100
6101     case BUILT_IN_BZERO:
6102       target = expand_builtin_bzero (exp);
6103       if (target)
6104         return target;
6105       break;
6106
6107     case BUILT_IN_STRCMP:
6108       target = expand_builtin_strcmp (exp, target);
6109       if (target)
6110         return target;
6111       break;
6112
6113     case BUILT_IN_STRNCMP:
6114       target = expand_builtin_strncmp (exp, target, mode);
6115       if (target)
6116         return target;
6117       break;
6118
6119     case BUILT_IN_BCMP:
6120     case BUILT_IN_MEMCMP:
6121       target = expand_builtin_memcmp (exp, target, mode);
6122       if (target)
6123         return target;
6124       break;
6125
6126     case BUILT_IN_SETJMP:
6127       /* This should have been lowered to the builtins below.  */
6128       gcc_unreachable ();
6129
6130     case BUILT_IN_SETJMP_SETUP:
6131       /* __builtin_setjmp_setup is passed a pointer to an array of five words
6132           and the receiver label.  */
6133       if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6134         {
6135           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6136                                       VOIDmode, EXPAND_NORMAL);
6137           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6138           rtx label_r = label_rtx (label);
6139
6140           /* This is copied from the handling of non-local gotos.  */
6141           expand_builtin_setjmp_setup (buf_addr, label_r);
6142           nonlocal_goto_handler_labels
6143             = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6144                                  nonlocal_goto_handler_labels);
6145           /* ??? Do not let expand_label treat us as such since we would
6146              not want to be both on the list of non-local labels and on
6147              the list of forced labels.  */
6148           FORCED_LABEL (label) = 0;
6149           return const0_rtx;
6150         }
6151       break;
6152
6153     case BUILT_IN_SETJMP_DISPATCHER:
6154        /* __builtin_setjmp_dispatcher is passed the dispatcher label.  */
6155       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6156         {
6157           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6158           rtx label_r = label_rtx (label);
6159
6160           /* Remove the dispatcher label from the list of non-local labels
6161              since the receiver labels have been added to it above.  */
6162           remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6163           return const0_rtx;
6164         }
6165       break;
6166
6167     case BUILT_IN_SETJMP_RECEIVER:
6168        /* __builtin_setjmp_receiver is passed the receiver label.  */
6169       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6170         {
6171           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6172           rtx label_r = label_rtx (label);
6173
6174           expand_builtin_setjmp_receiver (label_r);
6175           return const0_rtx;
6176         }
6177       break;
6178
6179       /* __builtin_longjmp is passed a pointer to an array of five words.
6180          It's similar to the C library longjmp function but works with
6181          __builtin_setjmp above.  */
6182     case BUILT_IN_LONGJMP:
6183       if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6184         {
6185           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6186                                       VOIDmode, EXPAND_NORMAL);
6187           rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6188
6189           if (value != const1_rtx)
6190             {
6191               error ("%<__builtin_longjmp%> second argument must be 1");
6192               return const0_rtx;
6193             }
6194
6195           expand_builtin_longjmp (buf_addr, value);
6196           return const0_rtx;
6197         }
6198       break;
6199
6200     case BUILT_IN_NONLOCAL_GOTO:
6201       target = expand_builtin_nonlocal_goto (exp);
6202       if (target)
6203         return target;
6204       break;
6205
6206       /* This updates the setjmp buffer that is its argument with the value
6207          of the current stack pointer.  */
6208     case BUILT_IN_UPDATE_SETJMP_BUF:
6209       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6210         {
6211           rtx buf_addr
6212             = expand_normal (CALL_EXPR_ARG (exp, 0));
6213
6214           expand_builtin_update_setjmp_buf (buf_addr);
6215           return const0_rtx;
6216         }
6217       break;
6218
6219     case BUILT_IN_TRAP:
6220       expand_builtin_trap ();
6221       return const0_rtx;
6222
6223     case BUILT_IN_UNREACHABLE:
6224       expand_builtin_unreachable ();
6225       return const0_rtx;
6226
6227     CASE_FLT_FN (BUILT_IN_SIGNBIT):
6228     case BUILT_IN_SIGNBITD32:
6229     case BUILT_IN_SIGNBITD64:
6230     case BUILT_IN_SIGNBITD128:
6231       target = expand_builtin_signbit (exp, target);
6232       if (target)
6233         return target;
6234       break;
6235
6236       /* Various hooks for the DWARF 2 __throw routine.  */
6237     case BUILT_IN_UNWIND_INIT:
6238       expand_builtin_unwind_init ();
6239       return const0_rtx;
6240     case BUILT_IN_DWARF_CFA:
6241       return virtual_cfa_rtx;
6242 #ifdef DWARF2_UNWIND_INFO
6243     case BUILT_IN_DWARF_SP_COLUMN:
6244       return expand_builtin_dwarf_sp_column ();
6245     case BUILT_IN_INIT_DWARF_REG_SIZES:
6246       expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6247       return const0_rtx;
6248 #endif
6249     case BUILT_IN_FROB_RETURN_ADDR:
6250       return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6251     case BUILT_IN_EXTRACT_RETURN_ADDR:
6252       return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6253     case BUILT_IN_EH_RETURN:
6254       expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6255                                 CALL_EXPR_ARG (exp, 1));
6256       return const0_rtx;
6257 #ifdef EH_RETURN_DATA_REGNO
6258     case BUILT_IN_EH_RETURN_DATA_REGNO:
6259       return expand_builtin_eh_return_data_regno (exp);
6260 #endif
6261     case BUILT_IN_EXTEND_POINTER:
6262       return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6263     case BUILT_IN_EH_POINTER:
6264       return expand_builtin_eh_pointer (exp);
6265     case BUILT_IN_EH_FILTER:
6266       return expand_builtin_eh_filter (exp);
6267     case BUILT_IN_EH_COPY_VALUES:
6268       return expand_builtin_eh_copy_values (exp);
6269
6270     case BUILT_IN_VA_START:
6271       return expand_builtin_va_start (exp);
6272     case BUILT_IN_VA_END:
6273       return expand_builtin_va_end (exp);
6274     case BUILT_IN_VA_COPY:
6275       return expand_builtin_va_copy (exp);
6276     case BUILT_IN_EXPECT:
6277       return expand_builtin_expect (exp, target);
6278     case BUILT_IN_PREFETCH:
6279       expand_builtin_prefetch (exp);
6280       return const0_rtx;
6281
6282     case BUILT_IN_PROFILE_FUNC_ENTER:
6283       return expand_builtin_profile_func (false);
6284     case BUILT_IN_PROFILE_FUNC_EXIT:
6285       return expand_builtin_profile_func (true);
6286
6287     case BUILT_IN_INIT_TRAMPOLINE:
6288       return expand_builtin_init_trampoline (exp);
6289     case BUILT_IN_ADJUST_TRAMPOLINE:
6290       return expand_builtin_adjust_trampoline (exp);
6291
6292     case BUILT_IN_FORK:
6293     case BUILT_IN_EXECL:
6294     case BUILT_IN_EXECV:
6295     case BUILT_IN_EXECLP:
6296     case BUILT_IN_EXECLE:
6297     case BUILT_IN_EXECVP:
6298     case BUILT_IN_EXECVE:
6299       target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6300       if (target)
6301         return target;
6302       break;
6303
6304     case BUILT_IN_FETCH_AND_ADD_1:
6305     case BUILT_IN_FETCH_AND_ADD_2:
6306     case BUILT_IN_FETCH_AND_ADD_4:
6307     case BUILT_IN_FETCH_AND_ADD_8:
6308     case BUILT_IN_FETCH_AND_ADD_16:
6309       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6310       target = expand_builtin_sync_operation (mode, exp, PLUS,
6311                                               false, target, ignore);
6312       if (target)
6313         return target;
6314       break;
6315
6316     case BUILT_IN_FETCH_AND_SUB_1:
6317     case BUILT_IN_FETCH_AND_SUB_2:
6318     case BUILT_IN_FETCH_AND_SUB_4:
6319     case BUILT_IN_FETCH_AND_SUB_8:
6320     case BUILT_IN_FETCH_AND_SUB_16:
6321       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6322       target = expand_builtin_sync_operation (mode, exp, MINUS,
6323                                               false, target, ignore);
6324       if (target)
6325         return target;
6326       break;
6327
6328     case BUILT_IN_FETCH_AND_OR_1:
6329     case BUILT_IN_FETCH_AND_OR_2:
6330     case BUILT_IN_FETCH_AND_OR_4:
6331     case BUILT_IN_FETCH_AND_OR_8:
6332     case BUILT_IN_FETCH_AND_OR_16:
6333       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6334       target = expand_builtin_sync_operation (mode, exp, IOR,
6335                                               false, target, ignore);
6336       if (target)
6337         return target;
6338       break;
6339
6340     case BUILT_IN_FETCH_AND_AND_1:
6341     case BUILT_IN_FETCH_AND_AND_2:
6342     case BUILT_IN_FETCH_AND_AND_4:
6343     case BUILT_IN_FETCH_AND_AND_8:
6344     case BUILT_IN_FETCH_AND_AND_16:
6345       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6346       target = expand_builtin_sync_operation (mode, exp, AND,
6347                                               false, target, ignore);
6348       if (target)
6349         return target;
6350       break;
6351
6352     case BUILT_IN_FETCH_AND_XOR_1:
6353     case BUILT_IN_FETCH_AND_XOR_2:
6354     case BUILT_IN_FETCH_AND_XOR_4:
6355     case BUILT_IN_FETCH_AND_XOR_8:
6356     case BUILT_IN_FETCH_AND_XOR_16:
6357       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6358       target = expand_builtin_sync_operation (mode, exp, XOR,
6359                                               false, target, ignore);
6360       if (target)
6361         return target;
6362       break;
6363
6364     case BUILT_IN_FETCH_AND_NAND_1:
6365     case BUILT_IN_FETCH_AND_NAND_2:
6366     case BUILT_IN_FETCH_AND_NAND_4:
6367     case BUILT_IN_FETCH_AND_NAND_8:
6368     case BUILT_IN_FETCH_AND_NAND_16:
6369       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6370       target = expand_builtin_sync_operation (mode, exp, NOT,
6371                                               false, target, ignore);
6372       if (target)
6373         return target;
6374       break;
6375
6376     case BUILT_IN_ADD_AND_FETCH_1:
6377     case BUILT_IN_ADD_AND_FETCH_2:
6378     case BUILT_IN_ADD_AND_FETCH_4:
6379     case BUILT_IN_ADD_AND_FETCH_8:
6380     case BUILT_IN_ADD_AND_FETCH_16:
6381       mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6382       target = expand_builtin_sync_operation (mode, exp, PLUS,
6383                                               true, target, ignore);
6384       if (target)
6385         return target;
6386       break;
6387
6388     case BUILT_IN_SUB_AND_FETCH_1:
6389     case BUILT_IN_SUB_AND_FETCH_2:
6390     case BUILT_IN_SUB_AND_FETCH_4:
6391     case BUILT_IN_SUB_AND_FETCH_8:
6392     case BUILT_IN_SUB_AND_FETCH_16:
6393       mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6394       target = expand_builtin_sync_operation (mode, exp, MINUS,
6395                                               true, target, ignore);
6396       if (target)
6397         return target;
6398       break;
6399
6400     case BUILT_IN_OR_AND_FETCH_1:
6401     case BUILT_IN_OR_AND_FETCH_2:
6402     case BUILT_IN_OR_AND_FETCH_4:
6403     case BUILT_IN_OR_AND_FETCH_8:
6404     case BUILT_IN_OR_AND_FETCH_16:
6405       mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6406       target = expand_builtin_sync_operation (mode, exp, IOR,
6407                                               true, target, ignore);
6408       if (target)
6409         return target;
6410       break;
6411
6412     case BUILT_IN_AND_AND_FETCH_1:
6413     case BUILT_IN_AND_AND_FETCH_2:
6414     case BUILT_IN_AND_AND_FETCH_4:
6415     case BUILT_IN_AND_AND_FETCH_8:
6416     case BUILT_IN_AND_AND_FETCH_16:
6417       mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6418       target = expand_builtin_sync_operation (mode, exp, AND,
6419                                               true, target, ignore);
6420       if (target)
6421         return target;
6422       break;
6423
6424     case BUILT_IN_XOR_AND_FETCH_1:
6425     case BUILT_IN_XOR_AND_FETCH_2:
6426     case BUILT_IN_XOR_AND_FETCH_4:
6427     case BUILT_IN_XOR_AND_FETCH_8:
6428     case BUILT_IN_XOR_AND_FETCH_16:
6429       mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6430       target = expand_builtin_sync_operation (mode, exp, XOR,
6431                                               true, target, ignore);
6432       if (target)
6433         return target;
6434       break;
6435
6436     case BUILT_IN_NAND_AND_FETCH_1:
6437     case BUILT_IN_NAND_AND_FETCH_2:
6438     case BUILT_IN_NAND_AND_FETCH_4:
6439     case BUILT_IN_NAND_AND_FETCH_8:
6440     case BUILT_IN_NAND_AND_FETCH_16:
6441       mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6442       target = expand_builtin_sync_operation (mode, exp, NOT,
6443                                               true, target, ignore);
6444       if (target)
6445         return target;
6446       break;
6447
6448     case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6449     case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6450     case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6451     case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6452     case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6453       if (mode == VOIDmode)
6454         mode = TYPE_MODE (boolean_type_node);
6455       if (!target || !register_operand (target, mode))
6456         target = gen_reg_rtx (mode);
6457
6458       mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6459       target = expand_builtin_compare_and_swap (mode, exp, true, target);
6460       if (target)
6461         return target;
6462       break;
6463
6464     case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6465     case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6466     case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6467     case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6468     case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6469       mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6470       target = expand_builtin_compare_and_swap (mode, exp, false, target);
6471       if (target)
6472         return target;
6473       break;
6474
6475     case BUILT_IN_LOCK_TEST_AND_SET_1:
6476     case BUILT_IN_LOCK_TEST_AND_SET_2:
6477     case BUILT_IN_LOCK_TEST_AND_SET_4:
6478     case BUILT_IN_LOCK_TEST_AND_SET_8:
6479     case BUILT_IN_LOCK_TEST_AND_SET_16:
6480       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6481       target = expand_builtin_lock_test_and_set (mode, exp, target);
6482       if (target)
6483         return target;
6484       break;
6485
6486     case BUILT_IN_LOCK_RELEASE_1:
6487     case BUILT_IN_LOCK_RELEASE_2:
6488     case BUILT_IN_LOCK_RELEASE_4:
6489     case BUILT_IN_LOCK_RELEASE_8:
6490     case BUILT_IN_LOCK_RELEASE_16:
6491       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6492       expand_builtin_lock_release (mode, exp);
6493       return const0_rtx;
6494
6495     case BUILT_IN_SYNCHRONIZE:
6496       expand_builtin_synchronize ();
6497       return const0_rtx;
6498
6499     case BUILT_IN_OBJECT_SIZE:
6500       return expand_builtin_object_size (exp);
6501
6502     case BUILT_IN_MEMCPY_CHK:
6503     case BUILT_IN_MEMPCPY_CHK:
6504     case BUILT_IN_MEMMOVE_CHK:
6505     case BUILT_IN_MEMSET_CHK:
6506       target = expand_builtin_memory_chk (exp, target, mode, fcode);
6507       if (target)
6508         return target;
6509       break;
6510
6511     case BUILT_IN_STRCPY_CHK:
6512     case BUILT_IN_STPCPY_CHK:
6513     case BUILT_IN_STRNCPY_CHK:
6514     case BUILT_IN_STRCAT_CHK:
6515     case BUILT_IN_STRNCAT_CHK:
6516     case BUILT_IN_SNPRINTF_CHK:
6517     case BUILT_IN_VSNPRINTF_CHK:
6518       maybe_emit_chk_warning (exp, fcode);
6519       break;
6520
6521     case BUILT_IN_SPRINTF_CHK:
6522     case BUILT_IN_VSPRINTF_CHK:
6523       maybe_emit_sprintf_chk_warning (exp, fcode);
6524       break;
6525
6526     case BUILT_IN_FREE:
6527       maybe_emit_free_warning (exp);
6528       break;
6529
6530     default:    /* just do library call, if unknown builtin */
6531       break;
6532     }
6533
6534   /* The switch statement above can drop through to cause the function
6535      to be called normally.  */
6536   return expand_call (exp, target, ignore);
6537 }
6538
6539 /* Determine whether a tree node represents a call to a built-in
6540    function.  If the tree T is a call to a built-in function with
6541    the right number of arguments of the appropriate types, return
6542    the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6543    Otherwise the return value is END_BUILTINS.  */
6544
6545 enum built_in_function
6546 builtin_mathfn_code (const_tree t)
6547 {
6548   const_tree fndecl, arg, parmlist;
6549   const_tree argtype, parmtype;
6550   const_call_expr_arg_iterator iter;
6551
6552   if (TREE_CODE (t) != CALL_EXPR
6553       || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6554     return END_BUILTINS;
6555
6556   fndecl = get_callee_fndecl (t);
6557   if (fndecl == NULL_TREE
6558       || TREE_CODE (fndecl) != FUNCTION_DECL
6559       || ! DECL_BUILT_IN (fndecl)
6560       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6561     return END_BUILTINS;
6562
6563   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6564   init_const_call_expr_arg_iterator (t, &iter);
6565   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6566     {
6567       /* If a function doesn't take a variable number of arguments,
6568          the last element in the list will have type `void'.  */
6569       parmtype = TREE_VALUE (parmlist);
6570       if (VOID_TYPE_P (parmtype))
6571         {
6572           if (more_const_call_expr_args_p (&iter))
6573             return END_BUILTINS;
6574           return DECL_FUNCTION_CODE (fndecl);
6575         }
6576
6577       if (! more_const_call_expr_args_p (&iter))
6578         return END_BUILTINS;
6579
6580       arg = next_const_call_expr_arg (&iter);
6581       argtype = TREE_TYPE (arg);
6582
6583       if (SCALAR_FLOAT_TYPE_P (parmtype))
6584         {
6585           if (! SCALAR_FLOAT_TYPE_P (argtype))
6586             return END_BUILTINS;
6587         }
6588       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6589         {
6590           if (! COMPLEX_FLOAT_TYPE_P (argtype))
6591             return END_BUILTINS;
6592         }
6593       else if (POINTER_TYPE_P (parmtype))
6594         {
6595           if (! POINTER_TYPE_P (argtype))
6596             return END_BUILTINS;
6597         }
6598       else if (INTEGRAL_TYPE_P (parmtype))
6599         {
6600           if (! INTEGRAL_TYPE_P (argtype))
6601             return END_BUILTINS;
6602         }
6603       else
6604         return END_BUILTINS;
6605     }
6606
6607   /* Variable-length argument list.  */
6608   return DECL_FUNCTION_CODE (fndecl);
6609 }
6610
6611 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6612    evaluate to a constant.  */
6613
6614 static tree
6615 fold_builtin_constant_p (tree arg)
6616 {
6617   /* We return 1 for a numeric type that's known to be a constant
6618      value at compile-time or for an aggregate type that's a
6619      literal constant.  */
6620   STRIP_NOPS (arg);
6621
6622   /* If we know this is a constant, emit the constant of one.  */
6623   if (CONSTANT_CLASS_P (arg)
6624       || (TREE_CODE (arg) == CONSTRUCTOR
6625           && TREE_CONSTANT (arg)))
6626     return integer_one_node;
6627   if (TREE_CODE (arg) == ADDR_EXPR)
6628     {
6629        tree op = TREE_OPERAND (arg, 0);
6630        if (TREE_CODE (op) == STRING_CST
6631            || (TREE_CODE (op) == ARRAY_REF
6632                && integer_zerop (TREE_OPERAND (op, 1))
6633                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6634          return integer_one_node;
6635     }
6636
6637   /* If this expression has side effects, show we don't know it to be a
6638      constant.  Likewise if it's a pointer or aggregate type since in
6639      those case we only want literals, since those are only optimized
6640      when generating RTL, not later.
6641      And finally, if we are compiling an initializer, not code, we
6642      need to return a definite result now; there's not going to be any
6643      more optimization done.  */
6644   if (TREE_SIDE_EFFECTS (arg)
6645       || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6646       || POINTER_TYPE_P (TREE_TYPE (arg))
6647       || cfun == 0
6648       || folding_initializer)
6649     return integer_zero_node;
6650
6651   return NULL_TREE;
6652 }
6653
6654 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6655    return it as a truthvalue.  */
6656
6657 static tree
6658 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6659 {
6660   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6661
6662   fn = built_in_decls[BUILT_IN_EXPECT];
6663   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6664   ret_type = TREE_TYPE (TREE_TYPE (fn));
6665   pred_type = TREE_VALUE (arg_types);
6666   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6667
6668   pred = fold_convert_loc (loc, pred_type, pred);
6669   expected = fold_convert_loc (loc, expected_type, expected);
6670   call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6671
6672   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6673                  build_int_cst (ret_type, 0));
6674 }
6675
6676 /* Fold a call to builtin_expect with arguments ARG0 and ARG1.  Return
6677    NULL_TREE if no simplification is possible.  */
6678
6679 static tree
6680 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
6681 {
6682   tree inner, fndecl;
6683   enum tree_code code;
6684
6685   /* If this is a builtin_expect within a builtin_expect keep the
6686      inner one.  See through a comparison against a constant.  It
6687      might have been added to create a thruthvalue.  */
6688   inner = arg0;
6689   if (COMPARISON_CLASS_P (inner)
6690       && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6691     inner = TREE_OPERAND (inner, 0);
6692
6693   if (TREE_CODE (inner) == CALL_EXPR
6694       && (fndecl = get_callee_fndecl (inner))
6695       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6696       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6697     return arg0;
6698
6699   /* Distribute the expected value over short-circuiting operators.
6700      See through the cast from truthvalue_type_node to long.  */
6701   inner = arg0;
6702   while (TREE_CODE (inner) == NOP_EXPR
6703          && INTEGRAL_TYPE_P (TREE_TYPE (inner))
6704          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
6705     inner = TREE_OPERAND (inner, 0);
6706
6707   code = TREE_CODE (inner);
6708   if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6709     {
6710       tree op0 = TREE_OPERAND (inner, 0);
6711       tree op1 = TREE_OPERAND (inner, 1);
6712
6713       op0 = build_builtin_expect_predicate (loc, op0, arg1);
6714       op1 = build_builtin_expect_predicate (loc, op1, arg1);
6715       inner = build2 (code, TREE_TYPE (inner), op0, op1);
6716
6717       return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6718     }
6719
6720   /* If the argument isn't invariant then there's nothing else we can do.  */
6721   if (!TREE_CONSTANT (arg0))
6722     return NULL_TREE;
6723
6724   /* If we expect that a comparison against the argument will fold to
6725      a constant return the constant.  In practice, this means a true
6726      constant or the address of a non-weak symbol.  */
6727   inner = arg0;
6728   STRIP_NOPS (inner);
6729   if (TREE_CODE (inner) == ADDR_EXPR)
6730     {
6731       do
6732         {
6733           inner = TREE_OPERAND (inner, 0);
6734         }
6735       while (TREE_CODE (inner) == COMPONENT_REF
6736              || TREE_CODE (inner) == ARRAY_REF);
6737       if ((TREE_CODE (inner) == VAR_DECL
6738            || TREE_CODE (inner) == FUNCTION_DECL)
6739           && DECL_WEAK (inner))
6740         return NULL_TREE;
6741     }
6742
6743   /* Otherwise, ARG0 already has the proper type for the return value.  */
6744   return arg0;
6745 }
6746
6747 /* Fold a call to __builtin_classify_type with argument ARG.  */
6748
6749 static tree
6750 fold_builtin_classify_type (tree arg)
6751 {
6752   if (arg == 0)
6753     return build_int_cst (NULL_TREE, no_type_class);
6754
6755   return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
6756 }
6757
6758 /* Fold a call to __builtin_strlen with argument ARG.  */
6759
6760 static tree
6761 fold_builtin_strlen (location_t loc, tree type, tree arg)
6762 {
6763   if (!validate_arg (arg, POINTER_TYPE))
6764     return NULL_TREE;
6765   else
6766     {
6767       tree len = c_strlen (arg, 0);
6768
6769       if (len)
6770         return fold_convert_loc (loc, type, len);
6771
6772       return NULL_TREE;
6773     }
6774 }
6775
6776 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
6777
6778 static tree
6779 fold_builtin_inf (location_t loc, tree type, int warn)
6780 {
6781   REAL_VALUE_TYPE real;
6782
6783   /* __builtin_inff is intended to be usable to define INFINITY on all
6784      targets.  If an infinity is not available, INFINITY expands "to a
6785      positive constant of type float that overflows at translation
6786      time", footnote "In this case, using INFINITY will violate the
6787      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6788      Thus we pedwarn to ensure this constraint violation is
6789      diagnosed.  */
6790   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6791     pedwarn (loc, 0, "target format does not support infinity");
6792
6793   real_inf (&real);
6794   return build_real (type, real);
6795 }
6796
6797 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG.  */
6798
6799 static tree
6800 fold_builtin_nan (tree arg, tree type, int quiet)
6801 {
6802   REAL_VALUE_TYPE real;
6803   const char *str;
6804
6805   if (!validate_arg (arg, POINTER_TYPE))
6806     return NULL_TREE;
6807   str = c_getstr (arg);
6808   if (!str)
6809     return NULL_TREE;
6810
6811   if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
6812     return NULL_TREE;
6813
6814   return build_real (type, real);
6815 }
6816
6817 /* Return true if the floating point expression T has an integer value.
6818    We also allow +Inf, -Inf and NaN to be considered integer values.  */
6819
6820 static bool
6821 integer_valued_real_p (tree t)
6822 {
6823   switch (TREE_CODE (t))
6824     {
6825     case FLOAT_EXPR:
6826       return true;
6827
6828     case ABS_EXPR:
6829     case SAVE_EXPR:
6830       return integer_valued_real_p (TREE_OPERAND (t, 0));
6831
6832     case COMPOUND_EXPR:
6833     case MODIFY_EXPR:
6834     case BIND_EXPR:
6835       return integer_valued_real_p (TREE_OPERAND (t, 1));
6836
6837     case PLUS_EXPR:
6838     case MINUS_EXPR:
6839     case MULT_EXPR:
6840     case MIN_EXPR:
6841     case MAX_EXPR:
6842       return integer_valued_real_p (TREE_OPERAND (t, 0))
6843              && integer_valued_real_p (TREE_OPERAND (t, 1));
6844
6845     case COND_EXPR:
6846       return integer_valued_real_p (TREE_OPERAND (t, 1))
6847              && integer_valued_real_p (TREE_OPERAND (t, 2));
6848
6849     case REAL_CST:
6850       return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
6851
6852     case NOP_EXPR:
6853       {
6854         tree type = TREE_TYPE (TREE_OPERAND (t, 0));
6855         if (TREE_CODE (type) == INTEGER_TYPE)
6856           return true;
6857         if (TREE_CODE (type) == REAL_TYPE)
6858           return integer_valued_real_p (TREE_OPERAND (t, 0));
6859         break;
6860       }
6861
6862     case CALL_EXPR:
6863       switch (builtin_mathfn_code (t))
6864         {
6865         CASE_FLT_FN (BUILT_IN_CEIL):
6866         CASE_FLT_FN (BUILT_IN_FLOOR):
6867         CASE_FLT_FN (BUILT_IN_NEARBYINT):
6868         CASE_FLT_FN (BUILT_IN_RINT):
6869         CASE_FLT_FN (BUILT_IN_ROUND):
6870         CASE_FLT_FN (BUILT_IN_TRUNC):
6871           return true;
6872
6873         CASE_FLT_FN (BUILT_IN_FMIN):
6874         CASE_FLT_FN (BUILT_IN_FMAX):
6875           return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
6876             && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
6877
6878         default:
6879           break;
6880         }
6881       break;
6882
6883     default:
6884       break;
6885     }
6886   return false;
6887 }
6888
6889 /* FNDECL is assumed to be a builtin where truncation can be propagated
6890    across (for instance floor((double)f) == (double)floorf (f).
6891    Do the transformation for a call with argument ARG.  */
6892
6893 static tree
6894 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
6895 {
6896   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6897
6898   if (!validate_arg (arg, REAL_TYPE))
6899     return NULL_TREE;
6900
6901   /* Integer rounding functions are idempotent.  */
6902   if (fcode == builtin_mathfn_code (arg))
6903     return arg;
6904
6905   /* If argument is already integer valued, and we don't need to worry
6906      about setting errno, there's no need to perform rounding.  */
6907   if (! flag_errno_math && integer_valued_real_p (arg))
6908     return arg;
6909
6910   if (optimize)
6911     {
6912       tree arg0 = strip_float_extensions (arg);
6913       tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
6914       tree newtype = TREE_TYPE (arg0);
6915       tree decl;
6916
6917       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6918           && (decl = mathfn_built_in (newtype, fcode)))
6919         return fold_convert_loc (loc, ftype,
6920                                  build_call_expr_loc (loc, decl, 1,
6921                                                   fold_convert_loc (loc,
6922                                                                     newtype,
6923                                                                     arg0)));
6924     }
6925   return NULL_TREE;
6926 }
6927
6928 /* FNDECL is assumed to be builtin which can narrow the FP type of
6929    the argument, for instance lround((double)f) -> lroundf (f).
6930    Do the transformation for a call with argument ARG.  */
6931
6932 static tree
6933 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
6934 {
6935   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6936
6937   if (!validate_arg (arg, REAL_TYPE))
6938     return NULL_TREE;
6939
6940   /* If argument is already integer valued, and we don't need to worry
6941      about setting errno, there's no need to perform rounding.  */
6942   if (! flag_errno_math && integer_valued_real_p (arg))
6943     return fold_build1_loc (loc, FIX_TRUNC_EXPR,
6944                         TREE_TYPE (TREE_TYPE (fndecl)), arg);
6945
6946   if (optimize)
6947     {
6948       tree ftype = TREE_TYPE (arg);
6949       tree arg0 = strip_float_extensions (arg);
6950       tree newtype = TREE_TYPE (arg0);
6951       tree decl;
6952
6953       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6954           && (decl = mathfn_built_in (newtype, fcode)))
6955         return build_call_expr_loc (loc, decl, 1,
6956                                 fold_convert_loc (loc, newtype, arg0));
6957     }
6958
6959   /* Canonicalize llround (x) to lround (x) on LP64 targets where
6960      sizeof (long long) == sizeof (long).  */
6961   if (TYPE_PRECISION (long_long_integer_type_node)
6962       == TYPE_PRECISION (long_integer_type_node))
6963     {
6964       tree newfn = NULL_TREE;
6965       switch (fcode)
6966         {
6967         CASE_FLT_FN (BUILT_IN_LLCEIL):
6968           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
6969           break;
6970
6971         CASE_FLT_FN (BUILT_IN_LLFLOOR):
6972           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
6973           break;
6974
6975         CASE_FLT_FN (BUILT_IN_LLROUND):
6976           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
6977           break;
6978
6979         CASE_FLT_FN (BUILT_IN_LLRINT):
6980           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
6981           break;
6982
6983         default:
6984           break;
6985         }
6986
6987       if (newfn)
6988         {
6989           tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
6990           return fold_convert_loc (loc,
6991                                    TREE_TYPE (TREE_TYPE (fndecl)), newcall);
6992         }
6993     }
6994
6995   return NULL_TREE;
6996 }
6997
6998 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG.  TYPE is the
6999    return type.  Return NULL_TREE if no simplification can be made.  */
7000
7001 static tree
7002 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7003 {
7004   tree res;
7005
7006   if (!validate_arg (arg, COMPLEX_TYPE)
7007       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7008     return NULL_TREE;
7009
7010   /* Calculate the result when the argument is a constant.  */
7011   if (TREE_CODE (arg) == COMPLEX_CST
7012       && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7013                               type, mpfr_hypot)))
7014     return res;
7015
7016   if (TREE_CODE (arg) == COMPLEX_EXPR)
7017     {
7018       tree real = TREE_OPERAND (arg, 0);
7019       tree imag = TREE_OPERAND (arg, 1);
7020
7021       /* If either part is zero, cabs is fabs of the other.  */
7022       if (real_zerop (real))
7023         return fold_build1_loc (loc, ABS_EXPR, type, imag);
7024       if (real_zerop (imag))
7025         return fold_build1_loc (loc, ABS_EXPR, type, real);
7026
7027       /* cabs(x+xi) -> fabs(x)*sqrt(2).  */
7028       if (flag_unsafe_math_optimizations
7029           && operand_equal_p (real, imag, OEP_PURE_SAME))
7030         {
7031           const REAL_VALUE_TYPE sqrt2_trunc
7032             = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7033           STRIP_NOPS (real);
7034           return fold_build2_loc (loc, MULT_EXPR, type,
7035                               fold_build1_loc (loc, ABS_EXPR, type, real),
7036                               build_real (type, sqrt2_trunc));
7037         }
7038     }
7039
7040   /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z).  */
7041   if (TREE_CODE (arg) == NEGATE_EXPR
7042       || TREE_CODE (arg) == CONJ_EXPR)
7043     return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7044
7045   /* Don't do this when optimizing for size.  */
7046   if (flag_unsafe_math_optimizations
7047       && optimize && optimize_function_for_speed_p (cfun))
7048     {
7049       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7050
7051       if (sqrtfn != NULL_TREE)
7052         {
7053           tree rpart, ipart, result;
7054
7055           arg = builtin_save_expr (arg);
7056
7057           rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7058           ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7059
7060           rpart = builtin_save_expr (rpart);
7061           ipart = builtin_save_expr (ipart);
7062
7063           result = fold_build2_loc (loc, PLUS_EXPR, type,
7064                                 fold_build2_loc (loc, MULT_EXPR, type,
7065                                              rpart, rpart),
7066                                 fold_build2_loc (loc, MULT_EXPR, type,
7067                                              ipart, ipart));
7068
7069           return build_call_expr_loc (loc, sqrtfn, 1, result);
7070         }
7071     }
7072
7073   return NULL_TREE;
7074 }
7075
7076 /* Build a complex (inf +- 0i) for the result of cproj.  TYPE is the
7077    complex tree type of the result.  If NEG is true, the imaginary
7078    zero is negative.  */
7079
7080 static tree
7081 build_complex_cproj (tree type, bool neg)
7082 {
7083   REAL_VALUE_TYPE rinf, rzero = dconst0;
7084
7085   real_inf (&rinf);
7086   rzero.sign = neg;
7087   return build_complex (type, build_real (TREE_TYPE (type), rinf),
7088                         build_real (TREE_TYPE (type), rzero));
7089 }
7090
7091 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG.  TYPE is the
7092    return type.  Return NULL_TREE if no simplification can be made.  */
7093
7094 static tree
7095 fold_builtin_cproj (location_t loc, tree arg, tree type)
7096 {
7097   if (!validate_arg (arg, COMPLEX_TYPE)
7098       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7099     return NULL_TREE;
7100
7101   /* If there are no infinities, return arg.  */
7102   if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type))))
7103     return non_lvalue_loc (loc, arg);
7104
7105   /* Calculate the result when the argument is a constant.  */
7106   if (TREE_CODE (arg) == COMPLEX_CST)
7107     {
7108       const REAL_VALUE_TYPE *real = TREE_REAL_CST_PTR (TREE_REALPART (arg));
7109       const REAL_VALUE_TYPE *imag = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
7110
7111       if (real_isinf (real) || real_isinf (imag))
7112         return build_complex_cproj (type, imag->sign);
7113       else
7114         return arg;
7115     }
7116   else if (TREE_CODE (arg) == COMPLEX_EXPR)
7117     {
7118       tree real = TREE_OPERAND (arg, 0);
7119       tree imag = TREE_OPERAND (arg, 1);
7120
7121       STRIP_NOPS (real);
7122       STRIP_NOPS (imag);
7123
7124       /* If the real part is inf and the imag part is known to be
7125          nonnegative, return (inf + 0i).  Remember side-effects are
7126          possible in the imag part.  */
7127       if (TREE_CODE (real) == REAL_CST
7128           && real_isinf (TREE_REAL_CST_PTR (real))
7129           && tree_expr_nonnegative_p (imag))
7130         return omit_one_operand_loc (loc, type,
7131                                      build_complex_cproj (type, false),
7132                                      arg);
7133
7134       /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7135          Remember side-effects are possible in the real part.  */
7136       if (TREE_CODE (imag) == REAL_CST
7137           && real_isinf (TREE_REAL_CST_PTR (imag)))
7138         return
7139           omit_one_operand_loc (loc, type,
7140                                 build_complex_cproj (type, TREE_REAL_CST_PTR
7141                                                      (imag)->sign), arg);
7142     }
7143
7144   return NULL_TREE;
7145 }
7146
7147 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7148    Return NULL_TREE if no simplification can be made.  */
7149
7150 static tree
7151 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7152 {
7153
7154   enum built_in_function fcode;
7155   tree res;
7156
7157   if (!validate_arg (arg, REAL_TYPE))
7158     return NULL_TREE;
7159
7160   /* Calculate the result when the argument is a constant.  */
7161   if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7162     return res;
7163
7164   /* Optimize sqrt(expN(x)) = expN(x*0.5).  */
7165   fcode = builtin_mathfn_code (arg);
7166   if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7167     {
7168       tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7169       arg = fold_build2_loc (loc, MULT_EXPR, type,
7170                          CALL_EXPR_ARG (arg, 0),
7171                          build_real (type, dconsthalf));
7172       return build_call_expr_loc (loc, expfn, 1, arg);
7173     }
7174
7175   /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)).  */
7176   if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7177     {
7178       tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7179
7180       if (powfn)
7181         {
7182           tree arg0 = CALL_EXPR_ARG (arg, 0);
7183           tree tree_root;
7184           /* The inner root was either sqrt or cbrt.  */
7185           /* This was a conditional expression but it triggered a bug
7186              in Sun C 5.5.  */
7187           REAL_VALUE_TYPE dconstroot;
7188           if (BUILTIN_SQRT_P (fcode))
7189             dconstroot = dconsthalf;
7190           else
7191             dconstroot = dconst_third ();
7192
7193           /* Adjust for the outer root.  */
7194           SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7195           dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7196           tree_root = build_real (type, dconstroot);
7197           return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7198         }
7199     }
7200
7201   /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5).  */
7202   if (flag_unsafe_math_optimizations
7203       && (fcode == BUILT_IN_POW
7204           || fcode == BUILT_IN_POWF
7205           || fcode == BUILT_IN_POWL))
7206     {
7207       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7208       tree arg0 = CALL_EXPR_ARG (arg, 0);
7209       tree arg1 = CALL_EXPR_ARG (arg, 1);
7210       tree narg1;
7211       if (!tree_expr_nonnegative_p (arg0))
7212         arg0 = build1 (ABS_EXPR, type, arg0);
7213       narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7214                            build_real (type, dconsthalf));
7215       return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7216     }
7217
7218   return NULL_TREE;
7219 }
7220
7221 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7222    Return NULL_TREE if no simplification can be made.  */
7223
7224 static tree
7225 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7226 {
7227   const enum built_in_function fcode = builtin_mathfn_code (arg);
7228   tree res;
7229
7230   if (!validate_arg (arg, REAL_TYPE))
7231     return NULL_TREE;
7232
7233   /* Calculate the result when the argument is a constant.  */
7234   if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7235     return res;
7236
7237   if (flag_unsafe_math_optimizations)
7238     {
7239       /* Optimize cbrt(expN(x)) -> expN(x/3).  */
7240       if (BUILTIN_EXPONENT_P (fcode))
7241         {
7242           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7243           const REAL_VALUE_TYPE third_trunc =
7244             real_value_truncate (TYPE_MODE (type), dconst_third ());
7245           arg = fold_build2_loc (loc, MULT_EXPR, type,
7246                              CALL_EXPR_ARG (arg, 0),
7247                              build_real (type, third_trunc));
7248           return build_call_expr_loc (loc, expfn, 1, arg);
7249         }
7250
7251       /* Optimize cbrt(sqrt(x)) -> pow(x,1/6).  */
7252       if (BUILTIN_SQRT_P (fcode))
7253         {
7254           tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7255
7256           if (powfn)
7257             {
7258               tree arg0 = CALL_EXPR_ARG (arg, 0);
7259               tree tree_root;
7260               REAL_VALUE_TYPE dconstroot = dconst_third ();
7261
7262               SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7263               dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7264               tree_root = build_real (type, dconstroot);
7265               return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7266             }
7267         }
7268
7269       /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative.  */
7270       if (BUILTIN_CBRT_P (fcode))
7271         {
7272           tree arg0 = CALL_EXPR_ARG (arg, 0);
7273           if (tree_expr_nonnegative_p (arg0))
7274             {
7275               tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7276
7277               if (powfn)
7278                 {
7279                   tree tree_root;
7280                   REAL_VALUE_TYPE dconstroot;
7281
7282                   real_arithmetic (&dconstroot, MULT_EXPR,
7283                                    dconst_third_ptr (), dconst_third_ptr ());
7284                   dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7285                   tree_root = build_real (type, dconstroot);
7286                   return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7287                 }
7288             }
7289         }
7290
7291       /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative.  */
7292       if (fcode == BUILT_IN_POW
7293           || fcode == BUILT_IN_POWF
7294           || fcode == BUILT_IN_POWL)
7295         {
7296           tree arg00 = CALL_EXPR_ARG (arg, 0);
7297           tree arg01 = CALL_EXPR_ARG (arg, 1);
7298           if (tree_expr_nonnegative_p (arg00))
7299             {
7300               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7301               const REAL_VALUE_TYPE dconstroot
7302                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7303               tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7304                                          build_real (type, dconstroot));
7305               return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7306             }
7307         }
7308     }
7309   return NULL_TREE;
7310 }
7311
7312 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7313    TYPE is the type of the return value.  Return NULL_TREE if no
7314    simplification can be made.  */
7315
7316 static tree
7317 fold_builtin_cos (location_t loc,
7318                   tree arg, tree type, tree fndecl)
7319 {
7320   tree res, narg;
7321
7322   if (!validate_arg (arg, REAL_TYPE))
7323     return NULL_TREE;
7324
7325   /* Calculate the result when the argument is a constant.  */
7326   if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7327     return res;
7328
7329   /* Optimize cos(-x) into cos (x).  */
7330   if ((narg = fold_strip_sign_ops (arg)))
7331     return build_call_expr_loc (loc, fndecl, 1, narg);
7332
7333   return NULL_TREE;
7334 }
7335
7336 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7337    Return NULL_TREE if no simplification can be made.  */
7338
7339 static tree
7340 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7341 {
7342   if (validate_arg (arg, REAL_TYPE))
7343     {
7344       tree res, narg;
7345
7346       /* Calculate the result when the argument is a constant.  */
7347       if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7348         return res;
7349
7350       /* Optimize cosh(-x) into cosh (x).  */
7351       if ((narg = fold_strip_sign_ops (arg)))
7352         return build_call_expr_loc (loc, fndecl, 1, narg);
7353     }
7354
7355   return NULL_TREE;
7356 }
7357
7358 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7359    argument ARG.  TYPE is the type of the return value.  Return
7360    NULL_TREE if no simplification can be made.  */
7361
7362 static tree
7363 fold_builtin_ccos (location_t loc, tree arg, tree type, tree fndecl,
7364                    bool hyper)
7365 {
7366   if (validate_arg (arg, COMPLEX_TYPE)
7367       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7368     {
7369       tree tmp;
7370
7371       /* Calculate the result when the argument is a constant.  */
7372       if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7373         return tmp;
7374
7375       /* Optimize fn(-x) into fn(x).  */
7376       if ((tmp = fold_strip_sign_ops (arg)))
7377         return build_call_expr_loc (loc, fndecl, 1, tmp);
7378     }
7379
7380   return NULL_TREE;
7381 }
7382
7383 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7384    Return NULL_TREE if no simplification can be made.  */
7385
7386 static tree
7387 fold_builtin_tan (tree arg, tree type)
7388 {
7389   enum built_in_function fcode;
7390   tree res;
7391
7392   if (!validate_arg (arg, REAL_TYPE))
7393     return NULL_TREE;
7394
7395   /* Calculate the result when the argument is a constant.  */
7396   if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7397     return res;
7398
7399   /* Optimize tan(atan(x)) = x.  */
7400   fcode = builtin_mathfn_code (arg);
7401   if (flag_unsafe_math_optimizations
7402       && (fcode == BUILT_IN_ATAN
7403           || fcode == BUILT_IN_ATANF
7404           || fcode == BUILT_IN_ATANL))
7405     return CALL_EXPR_ARG (arg, 0);
7406
7407   return NULL_TREE;
7408 }
7409
7410 /* Fold function call to builtin sincos, sincosf, or sincosl.  Return
7411    NULL_TREE if no simplification can be made.  */
7412
7413 static tree
7414 fold_builtin_sincos (location_t loc,
7415                      tree arg0, tree arg1, tree arg2)
7416 {
7417   tree type;
7418   tree res, fn, call;
7419
7420   if (!validate_arg (arg0, REAL_TYPE)
7421       || !validate_arg (arg1, POINTER_TYPE)
7422       || !validate_arg (arg2, POINTER_TYPE))
7423     return NULL_TREE;
7424
7425   type = TREE_TYPE (arg0);
7426
7427   /* Calculate the result when the argument is a constant.  */
7428   if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7429     return res;
7430
7431   /* Canonicalize sincos to cexpi.  */
7432   if (!TARGET_C99_FUNCTIONS)
7433     return NULL_TREE;
7434   fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7435   if (!fn)
7436     return NULL_TREE;
7437
7438   call = build_call_expr_loc (loc, fn, 1, arg0);
7439   call = builtin_save_expr (call);
7440
7441   return build2 (COMPOUND_EXPR, void_type_node,
7442                  build2 (MODIFY_EXPR, void_type_node,
7443                          build_fold_indirect_ref_loc (loc, arg1),
7444                          build1 (IMAGPART_EXPR, type, call)),
7445                  build2 (MODIFY_EXPR, void_type_node,
7446                          build_fold_indirect_ref_loc (loc, arg2),
7447                          build1 (REALPART_EXPR, type, call)));
7448 }
7449
7450 /* Fold function call to builtin cexp, cexpf, or cexpl.  Return
7451    NULL_TREE if no simplification can be made.  */
7452
7453 static tree
7454 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7455 {
7456   tree rtype;
7457   tree realp, imagp, ifn;
7458   tree res;
7459
7460   if (!validate_arg (arg0, COMPLEX_TYPE)
7461       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7462     return NULL_TREE;
7463
7464   /* Calculate the result when the argument is a constant.  */
7465   if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7466     return res;
7467
7468   rtype = TREE_TYPE (TREE_TYPE (arg0));
7469
7470   /* In case we can figure out the real part of arg0 and it is constant zero
7471      fold to cexpi.  */
7472   if (!TARGET_C99_FUNCTIONS)
7473     return NULL_TREE;
7474   ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7475   if (!ifn)
7476     return NULL_TREE;
7477
7478   if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7479       && real_zerop (realp))
7480     {
7481       tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7482       return build_call_expr_loc (loc, ifn, 1, narg);
7483     }
7484
7485   /* In case we can easily decompose real and imaginary parts split cexp
7486      to exp (r) * cexpi (i).  */
7487   if (flag_unsafe_math_optimizations
7488       && realp)
7489     {
7490       tree rfn, rcall, icall;
7491
7492       rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7493       if (!rfn)
7494         return NULL_TREE;
7495
7496       imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7497       if (!imagp)
7498         return NULL_TREE;
7499
7500       icall = build_call_expr_loc (loc, ifn, 1, imagp);
7501       icall = builtin_save_expr (icall);
7502       rcall = build_call_expr_loc (loc, rfn, 1, realp);
7503       rcall = builtin_save_expr (rcall);
7504       return fold_build2_loc (loc, COMPLEX_EXPR, type,
7505                           fold_build2_loc (loc, MULT_EXPR, rtype,
7506                                        rcall,
7507                                        fold_build1_loc (loc, REALPART_EXPR,
7508                                                     rtype, icall)),
7509                           fold_build2_loc (loc, MULT_EXPR, rtype,
7510                                        rcall,
7511                                        fold_build1_loc (loc, IMAGPART_EXPR,
7512                                                     rtype, icall)));
7513     }
7514
7515   return NULL_TREE;
7516 }
7517
7518 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7519    Return NULL_TREE if no simplification can be made.  */
7520
7521 static tree
7522 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7523 {
7524   if (!validate_arg (arg, REAL_TYPE))
7525     return NULL_TREE;
7526
7527   /* Optimize trunc of constant value.  */
7528   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7529     {
7530       REAL_VALUE_TYPE r, x;
7531       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7532
7533       x = TREE_REAL_CST (arg);
7534       real_trunc (&r, TYPE_MODE (type), &x);
7535       return build_real (type, r);
7536     }
7537
7538   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7539 }
7540
7541 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7542    Return NULL_TREE if no simplification can be made.  */
7543
7544 static tree
7545 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7546 {
7547   if (!validate_arg (arg, REAL_TYPE))
7548     return NULL_TREE;
7549
7550   /* Optimize floor of constant value.  */
7551   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7552     {
7553       REAL_VALUE_TYPE x;
7554
7555       x = TREE_REAL_CST (arg);
7556       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7557         {
7558           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7559           REAL_VALUE_TYPE r;
7560
7561           real_floor (&r, TYPE_MODE (type), &x);
7562           return build_real (type, r);
7563         }
7564     }
7565
7566   /* Fold floor (x) where x is nonnegative to trunc (x).  */
7567   if (tree_expr_nonnegative_p (arg))
7568     {
7569       tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7570       if (truncfn)
7571         return build_call_expr_loc (loc, truncfn, 1, arg);
7572     }
7573
7574   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7575 }
7576
7577 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7578    Return NULL_TREE if no simplification can be made.  */
7579
7580 static tree
7581 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7582 {
7583   if (!validate_arg (arg, REAL_TYPE))
7584     return NULL_TREE;
7585
7586   /* Optimize ceil of constant value.  */
7587   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7588     {
7589       REAL_VALUE_TYPE x;
7590
7591       x = TREE_REAL_CST (arg);
7592       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7593         {
7594           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7595           REAL_VALUE_TYPE r;
7596
7597           real_ceil (&r, TYPE_MODE (type), &x);
7598           return build_real (type, r);
7599         }
7600     }
7601
7602   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7603 }
7604
7605 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7606    Return NULL_TREE if no simplification can be made.  */
7607
7608 static tree
7609 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7610 {
7611   if (!validate_arg (arg, REAL_TYPE))
7612     return NULL_TREE;
7613
7614   /* Optimize round of constant value.  */
7615   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7616     {
7617       REAL_VALUE_TYPE x;
7618
7619       x = TREE_REAL_CST (arg);
7620       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7621         {
7622           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7623           REAL_VALUE_TYPE r;
7624
7625           real_round (&r, TYPE_MODE (type), &x);
7626           return build_real (type, r);
7627         }
7628     }
7629
7630   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7631 }
7632
7633 /* Fold function call to builtin lround, lroundf or lroundl (or the
7634    corresponding long long versions) and other rounding functions.  ARG
7635    is the argument to the call.  Return NULL_TREE if no simplification
7636    can be made.  */
7637
7638 static tree
7639 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7640 {
7641   if (!validate_arg (arg, REAL_TYPE))
7642     return NULL_TREE;
7643
7644   /* Optimize lround of constant value.  */
7645   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7646     {
7647       const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7648
7649       if (real_isfinite (&x))
7650         {
7651           tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7652           tree ftype = TREE_TYPE (arg);
7653           double_int val;
7654           REAL_VALUE_TYPE r;
7655
7656           switch (DECL_FUNCTION_CODE (fndecl))
7657             {
7658             CASE_FLT_FN (BUILT_IN_LFLOOR):
7659             CASE_FLT_FN (BUILT_IN_LLFLOOR):
7660               real_floor (&r, TYPE_MODE (ftype), &x);
7661               break;
7662
7663             CASE_FLT_FN (BUILT_IN_LCEIL):
7664             CASE_FLT_FN (BUILT_IN_LLCEIL):
7665               real_ceil (&r, TYPE_MODE (ftype), &x);
7666               break;
7667
7668             CASE_FLT_FN (BUILT_IN_LROUND):
7669             CASE_FLT_FN (BUILT_IN_LLROUND):
7670               real_round (&r, TYPE_MODE (ftype), &x);
7671               break;
7672
7673             default:
7674               gcc_unreachable ();
7675             }
7676
7677           real_to_integer2 ((HOST_WIDE_INT *)&val.low, &val.high, &r);
7678           if (double_int_fits_to_tree_p (itype, val))
7679             return double_int_to_tree (itype, val);
7680         }
7681     }
7682
7683   switch (DECL_FUNCTION_CODE (fndecl))
7684     {
7685     CASE_FLT_FN (BUILT_IN_LFLOOR):
7686     CASE_FLT_FN (BUILT_IN_LLFLOOR):
7687       /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x).  */
7688       if (tree_expr_nonnegative_p (arg))
7689         return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7690                             TREE_TYPE (TREE_TYPE (fndecl)), arg);
7691       break;
7692     default:;
7693     }
7694
7695   return fold_fixed_mathfn (loc, fndecl, arg);
7696 }
7697
7698 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7699    and their long and long long variants (i.e. ffsl and ffsll).  ARG is
7700    the argument to the call.  Return NULL_TREE if no simplification can
7701    be made.  */
7702
7703 static tree
7704 fold_builtin_bitop (tree fndecl, tree arg)
7705 {
7706   if (!validate_arg (arg, INTEGER_TYPE))
7707     return NULL_TREE;
7708
7709   /* Optimize for constant argument.  */
7710   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7711     {
7712       HOST_WIDE_INT hi, width, result;
7713       unsigned HOST_WIDE_INT lo;
7714       tree type;
7715
7716       type = TREE_TYPE (arg);
7717       width = TYPE_PRECISION (type);
7718       lo = TREE_INT_CST_LOW (arg);
7719
7720       /* Clear all the bits that are beyond the type's precision.  */
7721       if (width > HOST_BITS_PER_WIDE_INT)
7722         {
7723           hi = TREE_INT_CST_HIGH (arg);
7724           if (width < 2 * HOST_BITS_PER_WIDE_INT)
7725             hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7726         }
7727       else
7728         {
7729           hi = 0;
7730           if (width < HOST_BITS_PER_WIDE_INT)
7731             lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7732         }
7733
7734       switch (DECL_FUNCTION_CODE (fndecl))
7735         {
7736         CASE_INT_FN (BUILT_IN_FFS):
7737           if (lo != 0)
7738             result = ffs_hwi (lo);
7739           else if (hi != 0)
7740             result = HOST_BITS_PER_WIDE_INT + ffs_hwi (hi);
7741           else
7742             result = 0;
7743           break;
7744
7745         CASE_INT_FN (BUILT_IN_CLZ):
7746           if (hi != 0)
7747             result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7748           else if (lo != 0)
7749             result = width - floor_log2 (lo) - 1;
7750           else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7751             result = width;
7752           break;
7753
7754         CASE_INT_FN (BUILT_IN_CTZ):
7755           if (lo != 0)
7756             result = ctz_hwi (lo);
7757           else if (hi != 0)
7758             result = HOST_BITS_PER_WIDE_INT + ctz_hwi (hi);
7759           else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7760             result = width;
7761           break;
7762
7763         CASE_INT_FN (BUILT_IN_POPCOUNT):
7764           result = 0;
7765           while (lo)
7766             result++, lo &= lo - 1;
7767           while (hi)
7768             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7769           break;
7770
7771         CASE_INT_FN (BUILT_IN_PARITY):
7772           result = 0;
7773           while (lo)
7774             result++, lo &= lo - 1;
7775           while (hi)
7776             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7777           result &= 1;
7778           break;
7779
7780         default:
7781           gcc_unreachable ();
7782         }
7783
7784       return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7785     }
7786
7787   return NULL_TREE;
7788 }
7789
7790 /* Fold function call to builtin_bswap and the long and long long
7791    variants.  Return NULL_TREE if no simplification can be made.  */
7792 static tree
7793 fold_builtin_bswap (tree fndecl, tree arg)
7794 {
7795   if (! validate_arg (arg, INTEGER_TYPE))
7796     return NULL_TREE;
7797
7798   /* Optimize constant value.  */
7799   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7800     {
7801       HOST_WIDE_INT hi, width, r_hi = 0;
7802       unsigned HOST_WIDE_INT lo, r_lo = 0;
7803       tree type;
7804
7805       type = TREE_TYPE (arg);
7806       width = TYPE_PRECISION (type);
7807       lo = TREE_INT_CST_LOW (arg);
7808       hi = TREE_INT_CST_HIGH (arg);
7809
7810       switch (DECL_FUNCTION_CODE (fndecl))
7811         {
7812           case BUILT_IN_BSWAP32:
7813           case BUILT_IN_BSWAP64:
7814             {
7815               int s;
7816
7817               for (s = 0; s < width; s += 8)
7818                 {
7819                   int d = width - s - 8;
7820                   unsigned HOST_WIDE_INT byte;
7821
7822                   if (s < HOST_BITS_PER_WIDE_INT)
7823                     byte = (lo >> s) & 0xff;
7824                   else
7825                     byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
7826
7827                   if (d < HOST_BITS_PER_WIDE_INT)
7828                     r_lo |= byte << d;
7829                   else
7830                     r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
7831                 }
7832             }
7833
7834             break;
7835
7836         default:
7837           gcc_unreachable ();
7838         }
7839
7840       if (width < HOST_BITS_PER_WIDE_INT)
7841         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
7842       else
7843         return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
7844     }
7845
7846   return NULL_TREE;
7847 }
7848
7849 /* A subroutine of fold_builtin to fold the various logarithmic
7850    functions.  Return NULL_TREE if no simplification can me made.
7851    FUNC is the corresponding MPFR logarithm function.  */
7852
7853 static tree
7854 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
7855                         int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
7856 {
7857   if (validate_arg (arg, REAL_TYPE))
7858     {
7859       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7860       tree res;
7861       const enum built_in_function fcode = builtin_mathfn_code (arg);
7862
7863       /* Calculate the result when the argument is a constant.  */
7864       if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
7865         return res;
7866
7867       /* Special case, optimize logN(expN(x)) = x.  */
7868       if (flag_unsafe_math_optimizations
7869           && ((func == mpfr_log
7870                && (fcode == BUILT_IN_EXP
7871                    || fcode == BUILT_IN_EXPF
7872                    || fcode == BUILT_IN_EXPL))
7873               || (func == mpfr_log2
7874                   && (fcode == BUILT_IN_EXP2
7875                       || fcode == BUILT_IN_EXP2F
7876                       || fcode == BUILT_IN_EXP2L))
7877               || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
7878         return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
7879
7880       /* Optimize logN(func()) for various exponential functions.  We
7881          want to determine the value "x" and the power "exponent" in
7882          order to transform logN(x**exponent) into exponent*logN(x).  */
7883       if (flag_unsafe_math_optimizations)
7884         {
7885           tree exponent = 0, x = 0;
7886
7887           switch (fcode)
7888           {
7889           CASE_FLT_FN (BUILT_IN_EXP):
7890             /* Prepare to do logN(exp(exponent) -> exponent*logN(e).  */
7891             x = build_real (type, real_value_truncate (TYPE_MODE (type),
7892                                                        dconst_e ()));
7893             exponent = CALL_EXPR_ARG (arg, 0);
7894             break;
7895           CASE_FLT_FN (BUILT_IN_EXP2):
7896             /* Prepare to do logN(exp2(exponent) -> exponent*logN(2).  */
7897             x = build_real (type, dconst2);
7898             exponent = CALL_EXPR_ARG (arg, 0);
7899             break;
7900           CASE_FLT_FN (BUILT_IN_EXP10):
7901           CASE_FLT_FN (BUILT_IN_POW10):
7902             /* Prepare to do logN(exp10(exponent) -> exponent*logN(10).  */
7903             {
7904               REAL_VALUE_TYPE dconst10;
7905               real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
7906               x = build_real (type, dconst10);
7907             }
7908             exponent = CALL_EXPR_ARG (arg, 0);
7909             break;
7910           CASE_FLT_FN (BUILT_IN_SQRT):
7911             /* Prepare to do logN(sqrt(x) -> 0.5*logN(x).  */
7912             x = CALL_EXPR_ARG (arg, 0);
7913             exponent = build_real (type, dconsthalf);
7914             break;
7915           CASE_FLT_FN (BUILT_IN_CBRT):
7916             /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x).  */
7917             x = CALL_EXPR_ARG (arg, 0);
7918             exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
7919                                                               dconst_third ()));
7920             break;
7921           CASE_FLT_FN (BUILT_IN_POW):
7922             /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x).  */
7923             x = CALL_EXPR_ARG (arg, 0);
7924             exponent = CALL_EXPR_ARG (arg, 1);
7925             break;
7926           default:
7927             break;
7928           }
7929
7930           /* Now perform the optimization.  */
7931           if (x && exponent)
7932             {
7933               tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
7934               return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
7935             }
7936         }
7937     }
7938
7939   return NULL_TREE;
7940 }
7941
7942 /* Fold a builtin function call to hypot, hypotf, or hypotl.  Return
7943    NULL_TREE if no simplification can be made.  */
7944
7945 static tree
7946 fold_builtin_hypot (location_t loc, tree fndecl,
7947                     tree arg0, tree arg1, tree type)
7948 {
7949   tree res, narg0, narg1;
7950
7951   if (!validate_arg (arg0, REAL_TYPE)
7952       || !validate_arg (arg1, REAL_TYPE))
7953     return NULL_TREE;
7954
7955   /* Calculate the result when the argument is a constant.  */
7956   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
7957     return res;
7958
7959   /* If either argument to hypot has a negate or abs, strip that off.
7960      E.g. hypot(-x,fabs(y)) -> hypot(x,y).  */
7961   narg0 = fold_strip_sign_ops (arg0);
7962   narg1 = fold_strip_sign_ops (arg1);
7963   if (narg0 || narg1)
7964     {
7965       return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
7966                               narg1 ? narg1 : arg1);
7967     }
7968
7969   /* If either argument is zero, hypot is fabs of the other.  */
7970   if (real_zerop (arg0))
7971     return fold_build1_loc (loc, ABS_EXPR, type, arg1);
7972   else if (real_zerop (arg1))
7973     return fold_build1_loc (loc, ABS_EXPR, type, arg0);
7974
7975   /* hypot(x,x) -> fabs(x)*sqrt(2).  */
7976   if (flag_unsafe_math_optimizations
7977       && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
7978     {
7979       const REAL_VALUE_TYPE sqrt2_trunc
7980         = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7981       return fold_build2_loc (loc, MULT_EXPR, type,
7982                           fold_build1_loc (loc, ABS_EXPR, type, arg0),
7983                           build_real (type, sqrt2_trunc));
7984     }
7985
7986   return NULL_TREE;
7987 }
7988
7989
7990 /* Fold a builtin function call to pow, powf, or powl.  Return
7991    NULL_TREE if no simplification can be made.  */
7992 static tree
7993 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
7994 {
7995   tree res;
7996
7997   if (!validate_arg (arg0, REAL_TYPE)
7998        || !validate_arg (arg1, REAL_TYPE))
7999     return NULL_TREE;
8000
8001   /* Calculate the result when the argument is a constant.  */
8002   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8003     return res;
8004
8005   /* Optimize pow(1.0,y) = 1.0.  */
8006   if (real_onep (arg0))
8007     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8008
8009   if (TREE_CODE (arg1) == REAL_CST
8010       && !TREE_OVERFLOW (arg1))
8011     {
8012       REAL_VALUE_TYPE cint;
8013       REAL_VALUE_TYPE c;
8014       HOST_WIDE_INT n;
8015
8016       c = TREE_REAL_CST (arg1);
8017
8018       /* Optimize pow(x,0.0) = 1.0.  */
8019       if (REAL_VALUES_EQUAL (c, dconst0))
8020         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8021                                  arg0);
8022
8023       /* Optimize pow(x,1.0) = x.  */
8024       if (REAL_VALUES_EQUAL (c, dconst1))
8025         return arg0;
8026
8027       /* Optimize pow(x,-1.0) = 1.0/x.  */
8028       if (REAL_VALUES_EQUAL (c, dconstm1))
8029         return fold_build2_loc (loc, RDIV_EXPR, type,
8030                             build_real (type, dconst1), arg0);
8031
8032       /* Optimize pow(x,0.5) = sqrt(x).  */
8033       if (flag_unsafe_math_optimizations
8034           && REAL_VALUES_EQUAL (c, dconsthalf))
8035         {
8036           tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8037
8038           if (sqrtfn != NULL_TREE)
8039             return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8040         }
8041
8042       /* Optimize pow(x,1.0/3.0) = cbrt(x).  */
8043       if (flag_unsafe_math_optimizations)
8044         {
8045           const REAL_VALUE_TYPE dconstroot
8046             = real_value_truncate (TYPE_MODE (type), dconst_third ());
8047
8048           if (REAL_VALUES_EQUAL (c, dconstroot))
8049             {
8050               tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8051               if (cbrtfn != NULL_TREE)
8052                 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8053             }
8054         }
8055
8056       /* Check for an integer exponent.  */
8057       n = real_to_integer (&c);
8058       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8059       if (real_identical (&c, &cint))
8060         {
8061           /* Attempt to evaluate pow at compile-time, unless this should
8062              raise an exception.  */
8063           if (TREE_CODE (arg0) == REAL_CST
8064               && !TREE_OVERFLOW (arg0)
8065               && (n > 0
8066                   || (!flag_trapping_math && !flag_errno_math)
8067                   || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8068             {
8069               REAL_VALUE_TYPE x;
8070               bool inexact;
8071
8072               x = TREE_REAL_CST (arg0);
8073               inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8074               if (flag_unsafe_math_optimizations || !inexact)
8075                 return build_real (type, x);
8076             }
8077
8078           /* Strip sign ops from even integer powers.  */
8079           if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8080             {
8081               tree narg0 = fold_strip_sign_ops (arg0);
8082               if (narg0)
8083                 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8084             }
8085         }
8086     }
8087
8088   if (flag_unsafe_math_optimizations)
8089     {
8090       const enum built_in_function fcode = builtin_mathfn_code (arg0);
8091
8092       /* Optimize pow(expN(x),y) = expN(x*y).  */
8093       if (BUILTIN_EXPONENT_P (fcode))
8094         {
8095           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8096           tree arg = CALL_EXPR_ARG (arg0, 0);
8097           arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8098           return build_call_expr_loc (loc, expfn, 1, arg);
8099         }
8100
8101       /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
8102       if (BUILTIN_SQRT_P (fcode))
8103         {
8104           tree narg0 = CALL_EXPR_ARG (arg0, 0);
8105           tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8106                                     build_real (type, dconsthalf));
8107           return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8108         }
8109
8110       /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative.  */
8111       if (BUILTIN_CBRT_P (fcode))
8112         {
8113           tree arg = CALL_EXPR_ARG (arg0, 0);
8114           if (tree_expr_nonnegative_p (arg))
8115             {
8116               const REAL_VALUE_TYPE dconstroot
8117                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8118               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8119                                         build_real (type, dconstroot));
8120               return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8121             }
8122         }
8123
8124       /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative.  */
8125       if (fcode == BUILT_IN_POW
8126           || fcode == BUILT_IN_POWF
8127           || fcode == BUILT_IN_POWL)
8128         {
8129           tree arg00 = CALL_EXPR_ARG (arg0, 0);
8130           if (tree_expr_nonnegative_p (arg00))
8131             {
8132               tree arg01 = CALL_EXPR_ARG (arg0, 1);
8133               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8134               return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8135             }
8136         }
8137     }
8138
8139   return NULL_TREE;
8140 }
8141
8142 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8143    Return NULL_TREE if no simplification can be made.  */
8144 static tree
8145 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8146                    tree arg0, tree arg1, tree type)
8147 {
8148   if (!validate_arg (arg0, REAL_TYPE)
8149       || !validate_arg (arg1, INTEGER_TYPE))
8150     return NULL_TREE;
8151
8152   /* Optimize pow(1.0,y) = 1.0.  */
8153   if (real_onep (arg0))
8154     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8155
8156   if (host_integerp (arg1, 0))
8157     {
8158       HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8159
8160       /* Evaluate powi at compile-time.  */
8161       if (TREE_CODE (arg0) == REAL_CST
8162           && !TREE_OVERFLOW (arg0))
8163         {
8164           REAL_VALUE_TYPE x;
8165           x = TREE_REAL_CST (arg0);
8166           real_powi (&x, TYPE_MODE (type), &x, c);
8167           return build_real (type, x);
8168         }
8169
8170       /* Optimize pow(x,0) = 1.0.  */
8171       if (c == 0)
8172         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8173                                  arg0);
8174
8175       /* Optimize pow(x,1) = x.  */
8176       if (c == 1)
8177         return arg0;
8178
8179       /* Optimize pow(x,-1) = 1.0/x.  */
8180       if (c == -1)
8181         return fold_build2_loc (loc, RDIV_EXPR, type,
8182                            build_real (type, dconst1), arg0);
8183     }
8184
8185   return NULL_TREE;
8186 }
8187
8188 /* A subroutine of fold_builtin to fold the various exponent
8189    functions.  Return NULL_TREE if no simplification can be made.
8190    FUNC is the corresponding MPFR exponent function.  */
8191
8192 static tree
8193 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8194                        int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8195 {
8196   if (validate_arg (arg, REAL_TYPE))
8197     {
8198       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8199       tree res;
8200
8201       /* Calculate the result when the argument is a constant.  */
8202       if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8203         return res;
8204
8205       /* Optimize expN(logN(x)) = x.  */
8206       if (flag_unsafe_math_optimizations)
8207         {
8208           const enum built_in_function fcode = builtin_mathfn_code (arg);
8209
8210           if ((func == mpfr_exp
8211                && (fcode == BUILT_IN_LOG
8212                    || fcode == BUILT_IN_LOGF
8213                    || fcode == BUILT_IN_LOGL))
8214               || (func == mpfr_exp2
8215                   && (fcode == BUILT_IN_LOG2
8216                       || fcode == BUILT_IN_LOG2F
8217                       || fcode == BUILT_IN_LOG2L))
8218               || (func == mpfr_exp10
8219                   && (fcode == BUILT_IN_LOG10
8220                       || fcode == BUILT_IN_LOG10F
8221                       || fcode == BUILT_IN_LOG10L)))
8222             return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8223         }
8224     }
8225
8226   return NULL_TREE;
8227 }
8228
8229 /* Return true if VAR is a VAR_DECL or a component thereof.  */
8230
8231 static bool
8232 var_decl_component_p (tree var)
8233 {
8234   tree inner = var;
8235   while (handled_component_p (inner))
8236     inner = TREE_OPERAND (inner, 0);
8237   return SSA_VAR_P (inner);
8238 }
8239
8240 /* Fold function call to builtin memset.  Return
8241    NULL_TREE if no simplification can be made.  */
8242
8243 static tree
8244 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8245                      tree type, bool ignore)
8246 {
8247   tree var, ret, etype;
8248   unsigned HOST_WIDE_INT length, cval;
8249
8250   if (! validate_arg (dest, POINTER_TYPE)
8251       || ! validate_arg (c, INTEGER_TYPE)
8252       || ! validate_arg (len, INTEGER_TYPE))
8253     return NULL_TREE;
8254
8255   if (! host_integerp (len, 1))
8256     return NULL_TREE;
8257
8258   /* If the LEN parameter is zero, return DEST.  */
8259   if (integer_zerop (len))
8260     return omit_one_operand_loc (loc, type, dest, c);
8261
8262   if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
8263     return NULL_TREE;
8264
8265   var = dest;
8266   STRIP_NOPS (var);
8267   if (TREE_CODE (var) != ADDR_EXPR)
8268     return NULL_TREE;
8269
8270   var = TREE_OPERAND (var, 0);
8271   if (TREE_THIS_VOLATILE (var))
8272     return NULL_TREE;
8273
8274   etype = TREE_TYPE (var);
8275   if (TREE_CODE (etype) == ARRAY_TYPE)
8276     etype = TREE_TYPE (etype);
8277
8278   if (!INTEGRAL_TYPE_P (etype)
8279       && !POINTER_TYPE_P (etype))
8280     return NULL_TREE;
8281
8282   if (! var_decl_component_p (var))
8283     return NULL_TREE;
8284
8285   length = tree_low_cst (len, 1);
8286   if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8287       || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8288          < length)
8289     return NULL_TREE;
8290
8291   if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8292     return NULL_TREE;
8293
8294   if (integer_zerop (c))
8295     cval = 0;
8296   else
8297     {
8298       if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8299         return NULL_TREE;
8300
8301       cval = tree_low_cst (c, 1);
8302       cval &= 0xff;
8303       cval |= cval << 8;
8304       cval |= cval << 16;
8305       cval |= (cval << 31) << 1;
8306     }
8307
8308   ret = build_int_cst_type (etype, cval);
8309   var = build_fold_indirect_ref_loc (loc,
8310                                  fold_convert_loc (loc,
8311                                                    build_pointer_type (etype),
8312                                                    dest));
8313   ret = build2 (MODIFY_EXPR, etype, var, ret);
8314   if (ignore)
8315     return ret;
8316
8317   return omit_one_operand_loc (loc, type, dest, ret);
8318 }
8319
8320 /* Fold function call to builtin memset.  Return
8321    NULL_TREE if no simplification can be made.  */
8322
8323 static tree
8324 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8325 {
8326   if (! validate_arg (dest, POINTER_TYPE)
8327       || ! validate_arg (size, INTEGER_TYPE))
8328     return NULL_TREE;
8329
8330   if (!ignore)
8331     return NULL_TREE;
8332
8333   /* New argument list transforming bzero(ptr x, int y) to
8334      memset(ptr x, int 0, size_t y).   This is done this way
8335      so that if it isn't expanded inline, we fallback to
8336      calling bzero instead of memset.  */
8337
8338   return fold_builtin_memset (loc, dest, integer_zero_node,
8339                               fold_convert_loc (loc, sizetype, size),
8340                               void_type_node, ignore);
8341 }
8342
8343 /* Fold function call to builtin mem{{,p}cpy,move}.  Return
8344    NULL_TREE if no simplification can be made.
8345    If ENDP is 0, return DEST (like memcpy).
8346    If ENDP is 1, return DEST+LEN (like mempcpy).
8347    If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8348    If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8349    (memmove).   */
8350
8351 static tree
8352 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8353                         tree len, tree type, bool ignore, int endp)
8354 {
8355   tree destvar, srcvar, expr;
8356
8357   if (! validate_arg (dest, POINTER_TYPE)
8358       || ! validate_arg (src, POINTER_TYPE)
8359       || ! validate_arg (len, INTEGER_TYPE))
8360     return NULL_TREE;
8361
8362   /* If the LEN parameter is zero, return DEST.  */
8363   if (integer_zerop (len))
8364     return omit_one_operand_loc (loc, type, dest, src);
8365
8366   /* If SRC and DEST are the same (and not volatile), return
8367      DEST{,+LEN,+LEN-1}.  */
8368   if (operand_equal_p (src, dest, 0))
8369     expr = len;
8370   else
8371     {
8372       tree srctype, desttype;
8373       unsigned int src_align, dest_align;
8374       tree off0;
8375
8376       if (endp == 3)
8377         {
8378           src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8379           dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8380
8381           /* Both DEST and SRC must be pointer types.
8382              ??? This is what old code did.  Is the testing for pointer types
8383              really mandatory?
8384
8385              If either SRC is readonly or length is 1, we can use memcpy.  */
8386           if (!dest_align || !src_align)
8387             return NULL_TREE;
8388           if (readonly_data_expr (src)
8389               || (host_integerp (len, 1)
8390                   && (MIN (src_align, dest_align) / BITS_PER_UNIT
8391                       >= (unsigned HOST_WIDE_INT) tree_low_cst (len, 1))))
8392             {
8393               tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8394               if (!fn)
8395                 return NULL_TREE;
8396               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8397             }
8398
8399           /* If *src and *dest can't overlap, optimize into memcpy as well.  */
8400           if (TREE_CODE (src) == ADDR_EXPR
8401               && TREE_CODE (dest) == ADDR_EXPR)
8402             {
8403               tree src_base, dest_base, fn;
8404               HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8405               HOST_WIDE_INT size = -1;
8406               HOST_WIDE_INT maxsize = -1;
8407
8408               srcvar = TREE_OPERAND (src, 0);
8409               src_base = get_ref_base_and_extent (srcvar, &src_offset,
8410                                                   &size, &maxsize);
8411               destvar = TREE_OPERAND (dest, 0);
8412               dest_base = get_ref_base_and_extent (destvar, &dest_offset,
8413                                                    &size, &maxsize);
8414               if (host_integerp (len, 1))
8415                 maxsize = tree_low_cst (len, 1);
8416               else
8417                 maxsize = -1;
8418               src_offset /= BITS_PER_UNIT;
8419               dest_offset /= BITS_PER_UNIT;
8420               if (SSA_VAR_P (src_base)
8421                   && SSA_VAR_P (dest_base))
8422                 {
8423                   if (operand_equal_p (src_base, dest_base, 0)
8424                       && ranges_overlap_p (src_offset, maxsize,
8425                                            dest_offset, maxsize))
8426                     return NULL_TREE;
8427                 }
8428               else if (TREE_CODE (src_base) == MEM_REF
8429                        && TREE_CODE (dest_base) == MEM_REF)
8430                 {
8431                   double_int off;
8432                   if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8433                                          TREE_OPERAND (dest_base, 0), 0))
8434                     return NULL_TREE;
8435                   off = double_int_add (mem_ref_offset (src_base),
8436                                         shwi_to_double_int (src_offset));
8437                   if (!double_int_fits_in_shwi_p (off))
8438                     return NULL_TREE;
8439                   src_offset = off.low;
8440                   off = double_int_add (mem_ref_offset (dest_base),
8441                                         shwi_to_double_int (dest_offset));
8442                   if (!double_int_fits_in_shwi_p (off))
8443                     return NULL_TREE;
8444                   dest_offset = off.low;
8445                   if (ranges_overlap_p (src_offset, maxsize,
8446                                         dest_offset, maxsize))
8447                     return NULL_TREE;
8448                 }
8449               else
8450                 return NULL_TREE;
8451
8452               fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8453               if (!fn)
8454                 return NULL_TREE;
8455               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8456             }
8457
8458           /* If the destination and source do not alias optimize into
8459              memcpy as well.  */
8460           if ((is_gimple_min_invariant (dest)
8461                || TREE_CODE (dest) == SSA_NAME)
8462               && (is_gimple_min_invariant (src)
8463                   || TREE_CODE (src) == SSA_NAME))
8464             {
8465               ao_ref destr, srcr;
8466               ao_ref_init_from_ptr_and_size (&destr, dest, len);
8467               ao_ref_init_from_ptr_and_size (&srcr, src, len);
8468               if (!refs_may_alias_p_1 (&destr, &srcr, false))
8469                 {
8470                   tree fn;
8471                   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8472                   if (!fn)
8473                     return NULL_TREE;
8474                   return build_call_expr_loc (loc, fn, 3, dest, src, len);
8475                 }
8476             }
8477
8478           return NULL_TREE;
8479         }
8480
8481       if (!host_integerp (len, 0))
8482         return NULL_TREE;
8483       /* FIXME:
8484          This logic lose for arguments like (type *)malloc (sizeof (type)),
8485          since we strip the casts of up to VOID return value from malloc.
8486          Perhaps we ought to inherit type from non-VOID argument here?  */
8487       STRIP_NOPS (src);
8488       STRIP_NOPS (dest);
8489       /* As we fold (void *)(p + CST) to (void *)p + CST undo this here.  */
8490       if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8491         {
8492           tree tem = TREE_OPERAND (src, 0);
8493           STRIP_NOPS (tem);
8494           if (tem != TREE_OPERAND (src, 0))
8495             src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8496         }
8497       if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8498         {
8499           tree tem = TREE_OPERAND (dest, 0);
8500           STRIP_NOPS (tem);
8501           if (tem != TREE_OPERAND (dest, 0))
8502             dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8503         }
8504       srctype = TREE_TYPE (TREE_TYPE (src));
8505       if (srctype
8506           && TREE_CODE (srctype) == ARRAY_TYPE
8507           && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8508         {
8509           srctype = TREE_TYPE (srctype);
8510           STRIP_NOPS (src);
8511           src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8512         }
8513       desttype = TREE_TYPE (TREE_TYPE (dest));
8514       if (desttype
8515           && TREE_CODE (desttype) == ARRAY_TYPE
8516           && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8517         {
8518           desttype = TREE_TYPE (desttype);
8519           STRIP_NOPS (dest);
8520           dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8521         }
8522       if (!srctype || !desttype
8523           || TREE_ADDRESSABLE (srctype)
8524           || TREE_ADDRESSABLE (desttype)
8525           || !TYPE_SIZE_UNIT (srctype)
8526           || !TYPE_SIZE_UNIT (desttype)
8527           || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
8528           || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST)
8529         return NULL_TREE;
8530
8531       src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8532       dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8533       if (dest_align < TYPE_ALIGN (desttype)
8534           || src_align < TYPE_ALIGN (srctype))
8535         return NULL_TREE;
8536
8537       if (!ignore)
8538         dest = builtin_save_expr (dest);
8539
8540       /* Build accesses at offset zero with a ref-all character type.  */
8541       off0 = build_int_cst (build_pointer_type_for_mode (char_type_node,
8542                                                          ptr_mode, true), 0);
8543
8544       destvar = dest;
8545       STRIP_NOPS (destvar);
8546       if (TREE_CODE (destvar) == ADDR_EXPR
8547           && var_decl_component_p (TREE_OPERAND (destvar, 0))
8548           && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8549         destvar = fold_build2 (MEM_REF, desttype, destvar, off0);
8550       else
8551         destvar = NULL_TREE;
8552
8553       srcvar = src;
8554       STRIP_NOPS (srcvar);
8555       if (TREE_CODE (srcvar) == ADDR_EXPR
8556           && var_decl_component_p (TREE_OPERAND (srcvar, 0))
8557           && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len)
8558           && (!STRICT_ALIGNMENT
8559               || !destvar
8560               || src_align >= TYPE_ALIGN (desttype)))
8561         srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype,
8562                               srcvar, off0);
8563       else
8564         srcvar = NULL_TREE;
8565
8566       if (srcvar == NULL_TREE && destvar == NULL_TREE)
8567         return NULL_TREE;
8568
8569       if (srcvar == NULL_TREE)
8570         {
8571           if (STRICT_ALIGNMENT
8572               && src_align < TYPE_ALIGN (desttype))
8573             return NULL_TREE;
8574           STRIP_NOPS (src);
8575           srcvar = fold_build2 (MEM_REF, desttype, src, off0);
8576         }
8577       else if (destvar == NULL_TREE)
8578         {
8579           if (STRICT_ALIGNMENT
8580               && dest_align < TYPE_ALIGN (srctype))
8581             return NULL_TREE;
8582           STRIP_NOPS (dest);
8583           destvar = fold_build2 (MEM_REF, srctype, dest, off0);
8584         }
8585
8586       expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, srcvar);
8587     }
8588
8589   if (ignore)
8590     return expr;
8591
8592   if (endp == 0 || endp == 3)
8593     return omit_one_operand_loc (loc, type, dest, expr);
8594
8595   if (expr == len)
8596     expr = NULL_TREE;
8597
8598   if (endp == 2)
8599     len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
8600                        ssize_int (1));
8601
8602   len = fold_convert_loc (loc, sizetype, len);
8603   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8604   dest = fold_convert_loc (loc, type, dest);
8605   if (expr)
8606     dest = omit_one_operand_loc (loc, type, dest, expr);
8607   return dest;
8608 }
8609
8610 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8611    If LEN is not NULL, it represents the length of the string to be
8612    copied.  Return NULL_TREE if no simplification can be made.  */
8613
8614 tree
8615 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
8616 {
8617   tree fn;
8618
8619   if (!validate_arg (dest, POINTER_TYPE)
8620       || !validate_arg (src, POINTER_TYPE))
8621     return NULL_TREE;
8622
8623   /* If SRC and DEST are the same (and not volatile), return DEST.  */
8624   if (operand_equal_p (src, dest, 0))
8625     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
8626
8627   if (optimize_function_for_size_p (cfun))
8628     return NULL_TREE;
8629
8630   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8631   if (!fn)
8632     return NULL_TREE;
8633
8634   if (!len)
8635     {
8636       len = c_strlen (src, 1);
8637       if (! len || TREE_SIDE_EFFECTS (len))
8638         return NULL_TREE;
8639     }
8640
8641   len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8642   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8643                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8644 }
8645
8646 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
8647    Return NULL_TREE if no simplification can be made.  */
8648
8649 static tree
8650 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
8651 {
8652   tree fn, len, lenp1, call, type;
8653
8654   if (!validate_arg (dest, POINTER_TYPE)
8655       || !validate_arg (src, POINTER_TYPE))
8656     return NULL_TREE;
8657
8658   len = c_strlen (src, 1);
8659   if (!len
8660       || TREE_CODE (len) != INTEGER_CST)
8661     return NULL_TREE;
8662
8663   if (optimize_function_for_size_p (cfun)
8664       /* If length is zero it's small enough.  */
8665       && !integer_zerop (len))
8666     return NULL_TREE;
8667
8668   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8669   if (!fn)
8670     return NULL_TREE;
8671
8672   lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8673   /* We use dest twice in building our expression.  Save it from
8674      multiple expansions.  */
8675   dest = builtin_save_expr (dest);
8676   call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
8677
8678   type = TREE_TYPE (TREE_TYPE (fndecl));
8679   len = fold_convert_loc (loc, sizetype, len);
8680   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8681   dest = fold_convert_loc (loc, type, dest);
8682   dest = omit_one_operand_loc (loc, type, dest, call);
8683   return dest;
8684 }
8685
8686 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8687    If SLEN is not NULL, it represents the length of the source string.
8688    Return NULL_TREE if no simplification can be made.  */
8689
8690 tree
8691 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
8692                       tree src, tree len, tree slen)
8693 {
8694   tree fn;
8695
8696   if (!validate_arg (dest, POINTER_TYPE)
8697       || !validate_arg (src, POINTER_TYPE)
8698       || !validate_arg (len, INTEGER_TYPE))
8699     return NULL_TREE;
8700
8701   /* If the LEN parameter is zero, return DEST.  */
8702   if (integer_zerop (len))
8703     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8704
8705   /* We can't compare slen with len as constants below if len is not a
8706      constant.  */
8707   if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8708     return NULL_TREE;
8709
8710   if (!slen)
8711     slen = c_strlen (src, 1);
8712
8713   /* Now, we must be passed a constant src ptr parameter.  */
8714   if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8715     return NULL_TREE;
8716
8717   slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
8718
8719   /* We do not support simplification of this case, though we do
8720      support it when expanding trees into RTL.  */
8721   /* FIXME: generate a call to __builtin_memset.  */
8722   if (tree_int_cst_lt (slen, len))
8723     return NULL_TREE;
8724
8725   /* OK transform into builtin memcpy.  */
8726   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8727   if (!fn)
8728     return NULL_TREE;
8729   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8730                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8731 }
8732
8733 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
8734    arguments to the call, and TYPE is its return type.
8735    Return NULL_TREE if no simplification can be made.  */
8736
8737 static tree
8738 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
8739 {
8740   if (!validate_arg (arg1, POINTER_TYPE)
8741       || !validate_arg (arg2, INTEGER_TYPE)
8742       || !validate_arg (len, INTEGER_TYPE))
8743     return NULL_TREE;
8744   else
8745     {
8746       const char *p1;
8747
8748       if (TREE_CODE (arg2) != INTEGER_CST
8749           || !host_integerp (len, 1))
8750         return NULL_TREE;
8751
8752       p1 = c_getstr (arg1);
8753       if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
8754         {
8755           char c;
8756           const char *r;
8757           tree tem;
8758
8759           if (target_char_cast (arg2, &c))
8760             return NULL_TREE;
8761
8762           r = (char *) memchr (p1, c, tree_low_cst (len, 1));
8763
8764           if (r == NULL)
8765             return build_int_cst (TREE_TYPE (arg1), 0);
8766
8767           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
8768                              size_int (r - p1));
8769           return fold_convert_loc (loc, type, tem);
8770         }
8771       return NULL_TREE;
8772     }
8773 }
8774
8775 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8776    Return NULL_TREE if no simplification can be made.  */
8777
8778 static tree
8779 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
8780 {
8781   const char *p1, *p2;
8782
8783   if (!validate_arg (arg1, POINTER_TYPE)
8784       || !validate_arg (arg2, POINTER_TYPE)
8785       || !validate_arg (len, INTEGER_TYPE))
8786     return NULL_TREE;
8787
8788   /* If the LEN parameter is zero, return zero.  */
8789   if (integer_zerop (len))
8790     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8791                               arg1, arg2);
8792
8793   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8794   if (operand_equal_p (arg1, arg2, 0))
8795     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8796
8797   p1 = c_getstr (arg1);
8798   p2 = c_getstr (arg2);
8799
8800   /* If all arguments are constant, and the value of len is not greater
8801      than the lengths of arg1 and arg2, evaluate at compile-time.  */
8802   if (host_integerp (len, 1) && p1 && p2
8803       && compare_tree_int (len, strlen (p1) + 1) <= 0
8804       && compare_tree_int (len, strlen (p2) + 1) <= 0)
8805     {
8806       const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8807
8808       if (r > 0)
8809         return integer_one_node;
8810       else if (r < 0)
8811         return integer_minus_one_node;
8812       else
8813         return integer_zero_node;
8814     }
8815
8816   /* If len parameter is one, return an expression corresponding to
8817      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
8818   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8819     {
8820       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8821       tree cst_uchar_ptr_node
8822         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8823
8824       tree ind1
8825         = fold_convert_loc (loc, integer_type_node,
8826                             build1 (INDIRECT_REF, cst_uchar_node,
8827                                     fold_convert_loc (loc,
8828                                                       cst_uchar_ptr_node,
8829                                                       arg1)));
8830       tree ind2
8831         = fold_convert_loc (loc, integer_type_node,
8832                             build1 (INDIRECT_REF, cst_uchar_node,
8833                                     fold_convert_loc (loc,
8834                                                       cst_uchar_ptr_node,
8835                                                       arg2)));
8836       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8837     }
8838
8839   return NULL_TREE;
8840 }
8841
8842 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8843    Return NULL_TREE if no simplification can be made.  */
8844
8845 static tree
8846 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
8847 {
8848   const char *p1, *p2;
8849
8850   if (!validate_arg (arg1, POINTER_TYPE)
8851       || !validate_arg (arg2, POINTER_TYPE))
8852     return NULL_TREE;
8853
8854   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8855   if (operand_equal_p (arg1, arg2, 0))
8856     return integer_zero_node;
8857
8858   p1 = c_getstr (arg1);
8859   p2 = c_getstr (arg2);
8860
8861   if (p1 && p2)
8862     {
8863       const int i = strcmp (p1, p2);
8864       if (i < 0)
8865         return integer_minus_one_node;
8866       else if (i > 0)
8867         return integer_one_node;
8868       else
8869         return integer_zero_node;
8870     }
8871
8872   /* If the second arg is "", return *(const unsigned char*)arg1.  */
8873   if (p2 && *p2 == '\0')
8874     {
8875       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8876       tree cst_uchar_ptr_node
8877         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8878
8879       return fold_convert_loc (loc, integer_type_node,
8880                                build1 (INDIRECT_REF, cst_uchar_node,
8881                                        fold_convert_loc (loc,
8882                                                          cst_uchar_ptr_node,
8883                                                          arg1)));
8884     }
8885
8886   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
8887   if (p1 && *p1 == '\0')
8888     {
8889       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8890       tree cst_uchar_ptr_node
8891         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8892
8893       tree temp
8894         = fold_convert_loc (loc, integer_type_node,
8895                             build1 (INDIRECT_REF, cst_uchar_node,
8896                                     fold_convert_loc (loc,
8897                                                       cst_uchar_ptr_node,
8898                                                       arg2)));
8899       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8900     }
8901
8902   return NULL_TREE;
8903 }
8904
8905 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
8906    Return NULL_TREE if no simplification can be made.  */
8907
8908 static tree
8909 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
8910 {
8911   const char *p1, *p2;
8912
8913   if (!validate_arg (arg1, POINTER_TYPE)
8914       || !validate_arg (arg2, POINTER_TYPE)
8915       || !validate_arg (len, INTEGER_TYPE))
8916     return NULL_TREE;
8917
8918   /* If the LEN parameter is zero, return zero.  */
8919   if (integer_zerop (len))
8920     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8921                               arg1, arg2);
8922
8923   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8924   if (operand_equal_p (arg1, arg2, 0))
8925     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8926
8927   p1 = c_getstr (arg1);
8928   p2 = c_getstr (arg2);
8929
8930   if (host_integerp (len, 1) && p1 && p2)
8931     {
8932       const int i = strncmp (p1, p2, tree_low_cst (len, 1));
8933       if (i > 0)
8934         return integer_one_node;
8935       else if (i < 0)
8936         return integer_minus_one_node;
8937       else
8938         return integer_zero_node;
8939     }
8940
8941   /* If the second arg is "", and the length is greater than zero,
8942      return *(const unsigned char*)arg1.  */
8943   if (p2 && *p2 == '\0'
8944       && TREE_CODE (len) == INTEGER_CST
8945       && tree_int_cst_sgn (len) == 1)
8946     {
8947       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8948       tree cst_uchar_ptr_node
8949         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8950
8951       return fold_convert_loc (loc, integer_type_node,
8952                                build1 (INDIRECT_REF, cst_uchar_node,
8953                                        fold_convert_loc (loc,
8954                                                          cst_uchar_ptr_node,
8955                                                          arg1)));
8956     }
8957
8958   /* If the first arg is "", and the length is greater than zero,
8959      return -*(const unsigned char*)arg2.  */
8960   if (p1 && *p1 == '\0'
8961       && TREE_CODE (len) == INTEGER_CST
8962       && tree_int_cst_sgn (len) == 1)
8963     {
8964       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8965       tree cst_uchar_ptr_node
8966         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8967
8968       tree temp = fold_convert_loc (loc, integer_type_node,
8969                                     build1 (INDIRECT_REF, cst_uchar_node,
8970                                             fold_convert_loc (loc,
8971                                                               cst_uchar_ptr_node,
8972                                                               arg2)));
8973       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8974     }
8975
8976   /* If len parameter is one, return an expression corresponding to
8977      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
8978   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8979     {
8980       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8981       tree cst_uchar_ptr_node
8982         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8983
8984       tree ind1 = fold_convert_loc (loc, integer_type_node,
8985                                     build1 (INDIRECT_REF, cst_uchar_node,
8986                                             fold_convert_loc (loc,
8987                                                               cst_uchar_ptr_node,
8988                                                               arg1)));
8989       tree ind2 = fold_convert_loc (loc, integer_type_node,
8990                                     build1 (INDIRECT_REF, cst_uchar_node,
8991                                             fold_convert_loc (loc,
8992                                                               cst_uchar_ptr_node,
8993                                                               arg2)));
8994       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8995     }
8996
8997   return NULL_TREE;
8998 }
8999
9000 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9001    ARG.  Return NULL_TREE if no simplification can be made.  */
9002
9003 static tree
9004 fold_builtin_signbit (location_t loc, tree arg, tree type)
9005 {
9006   tree temp;
9007
9008   if (!validate_arg (arg, REAL_TYPE))
9009     return NULL_TREE;
9010
9011   /* If ARG is a compile-time constant, determine the result.  */
9012   if (TREE_CODE (arg) == REAL_CST
9013       && !TREE_OVERFLOW (arg))
9014     {
9015       REAL_VALUE_TYPE c;
9016
9017       c = TREE_REAL_CST (arg);
9018       temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
9019       return fold_convert_loc (loc, type, temp);
9020     }
9021
9022   /* If ARG is non-negative, the result is always zero.  */
9023   if (tree_expr_nonnegative_p (arg))
9024     return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9025
9026   /* If ARG's format doesn't have signed zeros, return "arg < 0.0".  */
9027   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9028     return fold_build2_loc (loc, LT_EXPR, type, arg,
9029                         build_real (TREE_TYPE (arg), dconst0));
9030
9031   return NULL_TREE;
9032 }
9033
9034 /* Fold function call to builtin copysign, copysignf or copysignl with
9035    arguments ARG1 and ARG2.  Return NULL_TREE if no simplification can
9036    be made.  */
9037
9038 static tree
9039 fold_builtin_copysign (location_t loc, tree fndecl,
9040                        tree arg1, tree arg2, tree type)
9041 {
9042   tree tem;
9043
9044   if (!validate_arg (arg1, REAL_TYPE)
9045       || !validate_arg (arg2, REAL_TYPE))
9046     return NULL_TREE;
9047
9048   /* copysign(X,X) is X.  */
9049   if (operand_equal_p (arg1, arg2, 0))
9050     return fold_convert_loc (loc, type, arg1);
9051
9052   /* If ARG1 and ARG2 are compile-time constants, determine the result.  */
9053   if (TREE_CODE (arg1) == REAL_CST
9054       && TREE_CODE (arg2) == REAL_CST
9055       && !TREE_OVERFLOW (arg1)
9056       && !TREE_OVERFLOW (arg2))
9057     {
9058       REAL_VALUE_TYPE c1, c2;
9059
9060       c1 = TREE_REAL_CST (arg1);
9061       c2 = TREE_REAL_CST (arg2);
9062       /* c1.sign := c2.sign.  */
9063       real_copysign (&c1, &c2);
9064       return build_real (type, c1);
9065     }
9066
9067   /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9068      Remember to evaluate Y for side-effects.  */
9069   if (tree_expr_nonnegative_p (arg2))
9070     return omit_one_operand_loc (loc, type,
9071                              fold_build1_loc (loc, ABS_EXPR, type, arg1),
9072                              arg2);
9073
9074   /* Strip sign changing operations for the first argument.  */
9075   tem = fold_strip_sign_ops (arg1);
9076   if (tem)
9077     return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9078
9079   return NULL_TREE;
9080 }
9081
9082 /* Fold a call to builtin isascii with argument ARG.  */
9083
9084 static tree
9085 fold_builtin_isascii (location_t loc, tree arg)
9086 {
9087   if (!validate_arg (arg, INTEGER_TYPE))
9088     return NULL_TREE;
9089   else
9090     {
9091       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
9092       arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9093                          build_int_cst (NULL_TREE,
9094                                         ~ (unsigned HOST_WIDE_INT) 0x7f));
9095       return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9096                           arg, integer_zero_node);
9097     }
9098 }
9099
9100 /* Fold a call to builtin toascii with argument ARG.  */
9101
9102 static tree
9103 fold_builtin_toascii (location_t loc, tree arg)
9104 {
9105   if (!validate_arg (arg, INTEGER_TYPE))
9106     return NULL_TREE;
9107
9108   /* Transform toascii(c) -> (c & 0x7f).  */
9109   return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9110                       build_int_cst (NULL_TREE, 0x7f));
9111 }
9112
9113 /* Fold a call to builtin isdigit with argument ARG.  */
9114
9115 static tree
9116 fold_builtin_isdigit (location_t loc, tree arg)
9117 {
9118   if (!validate_arg (arg, INTEGER_TYPE))
9119     return NULL_TREE;
9120   else
9121     {
9122       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
9123       /* According to the C standard, isdigit is unaffected by locale.
9124          However, it definitely is affected by the target character set.  */
9125       unsigned HOST_WIDE_INT target_digit0
9126         = lang_hooks.to_target_charset ('0');
9127
9128       if (target_digit0 == 0)
9129         return NULL_TREE;
9130
9131       arg = fold_convert_loc (loc, unsigned_type_node, arg);
9132       arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9133                          build_int_cst (unsigned_type_node, target_digit0));
9134       return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9135                           build_int_cst (unsigned_type_node, 9));
9136     }
9137 }
9138
9139 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
9140
9141 static tree
9142 fold_builtin_fabs (location_t loc, tree arg, tree type)
9143 {
9144   if (!validate_arg (arg, REAL_TYPE))
9145     return NULL_TREE;
9146
9147   arg = fold_convert_loc (loc, type, arg);
9148   if (TREE_CODE (arg) == REAL_CST)
9149     return fold_abs_const (arg, type);
9150   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9151 }
9152
9153 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
9154
9155 static tree
9156 fold_builtin_abs (location_t loc, tree arg, tree type)
9157 {
9158   if (!validate_arg (arg, INTEGER_TYPE))
9159     return NULL_TREE;
9160
9161   arg = fold_convert_loc (loc, type, arg);
9162   if (TREE_CODE (arg) == INTEGER_CST)
9163     return fold_abs_const (arg, type);
9164   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9165 }
9166
9167 /* Fold a call to builtin fmin or fmax.  */
9168
9169 static tree
9170 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9171                         tree type, bool max)
9172 {
9173   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9174     {
9175       /* Calculate the result when the argument is a constant.  */
9176       tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9177
9178       if (res)
9179         return res;
9180
9181       /* If either argument is NaN, return the other one.  Avoid the
9182          transformation if we get (and honor) a signalling NaN.  Using
9183          omit_one_operand() ensures we create a non-lvalue.  */
9184       if (TREE_CODE (arg0) == REAL_CST
9185           && real_isnan (&TREE_REAL_CST (arg0))
9186           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9187               || ! TREE_REAL_CST (arg0).signalling))
9188         return omit_one_operand_loc (loc, type, arg1, arg0);
9189       if (TREE_CODE (arg1) == REAL_CST
9190           && real_isnan (&TREE_REAL_CST (arg1))
9191           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9192               || ! TREE_REAL_CST (arg1).signalling))
9193         return omit_one_operand_loc (loc, type, arg0, arg1);
9194
9195       /* Transform fmin/fmax(x,x) -> x.  */
9196       if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9197         return omit_one_operand_loc (loc, type, arg0, arg1);
9198
9199       /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR.  C99 requires these
9200          functions to return the numeric arg if the other one is NaN.
9201          These tree codes don't honor that, so only transform if
9202          -ffinite-math-only is set.  C99 doesn't require -0.0 to be
9203          handled, so we don't have to worry about it either.  */
9204       if (flag_finite_math_only)
9205         return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9206                             fold_convert_loc (loc, type, arg0),
9207                             fold_convert_loc (loc, type, arg1));
9208     }
9209   return NULL_TREE;
9210 }
9211
9212 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
9213
9214 static tree
9215 fold_builtin_carg (location_t loc, tree arg, tree type)
9216 {
9217   if (validate_arg (arg, COMPLEX_TYPE)
9218       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9219     {
9220       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9221
9222       if (atan2_fn)
9223         {
9224           tree new_arg = builtin_save_expr (arg);
9225           tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9226           tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9227           return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9228         }
9229     }
9230
9231   return NULL_TREE;
9232 }
9233
9234 /* Fold a call to builtin logb/ilogb.  */
9235
9236 static tree
9237 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9238 {
9239   if (! validate_arg (arg, REAL_TYPE))
9240     return NULL_TREE;
9241
9242   STRIP_NOPS (arg);
9243
9244   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9245     {
9246       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9247
9248       switch (value->cl)
9249       {
9250       case rvc_nan:
9251       case rvc_inf:
9252         /* If arg is Inf or NaN and we're logb, return it.  */
9253         if (TREE_CODE (rettype) == REAL_TYPE)
9254           return fold_convert_loc (loc, rettype, arg);
9255         /* Fall through... */
9256       case rvc_zero:
9257         /* Zero may set errno and/or raise an exception for logb, also
9258            for ilogb we don't know FP_ILOGB0.  */
9259         return NULL_TREE;
9260       case rvc_normal:
9261         /* For normal numbers, proceed iff radix == 2.  In GCC,
9262            normalized significands are in the range [0.5, 1.0).  We
9263            want the exponent as if they were [1.0, 2.0) so get the
9264            exponent and subtract 1.  */
9265         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9266           return fold_convert_loc (loc, rettype,
9267                                    build_int_cst (NULL_TREE,
9268                                                   REAL_EXP (value)-1));
9269         break;
9270       }
9271     }
9272
9273   return NULL_TREE;
9274 }
9275
9276 /* Fold a call to builtin significand, if radix == 2.  */
9277
9278 static tree
9279 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9280 {
9281   if (! validate_arg (arg, REAL_TYPE))
9282     return NULL_TREE;
9283
9284   STRIP_NOPS (arg);
9285
9286   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9287     {
9288       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9289
9290       switch (value->cl)
9291       {
9292       case rvc_zero:
9293       case rvc_nan:
9294       case rvc_inf:
9295         /* If arg is +-0, +-Inf or +-NaN, then return it.  */
9296         return fold_convert_loc (loc, rettype, arg);
9297       case rvc_normal:
9298         /* For normal numbers, proceed iff radix == 2.  */
9299         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9300           {
9301             REAL_VALUE_TYPE result = *value;
9302             /* In GCC, normalized significands are in the range [0.5,
9303                1.0).  We want them to be [1.0, 2.0) so set the
9304                exponent to 1.  */
9305             SET_REAL_EXP (&result, 1);
9306             return build_real (rettype, result);
9307           }
9308         break;
9309       }
9310     }
9311
9312   return NULL_TREE;
9313 }
9314
9315 /* Fold a call to builtin frexp, we can assume the base is 2.  */
9316
9317 static tree
9318 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9319 {
9320   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9321     return NULL_TREE;
9322
9323   STRIP_NOPS (arg0);
9324
9325   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9326     return NULL_TREE;
9327
9328   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9329
9330   /* Proceed if a valid pointer type was passed in.  */
9331   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9332     {
9333       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9334       tree frac, exp;
9335
9336       switch (value->cl)
9337       {
9338       case rvc_zero:
9339         /* For +-0, return (*exp = 0, +-0).  */
9340         exp = integer_zero_node;
9341         frac = arg0;
9342         break;
9343       case rvc_nan:
9344       case rvc_inf:
9345         /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
9346         return omit_one_operand_loc (loc, rettype, arg0, arg1);
9347       case rvc_normal:
9348         {
9349           /* Since the frexp function always expects base 2, and in
9350              GCC normalized significands are already in the range
9351              [0.5, 1.0), we have exactly what frexp wants.  */
9352           REAL_VALUE_TYPE frac_rvt = *value;
9353           SET_REAL_EXP (&frac_rvt, 0);
9354           frac = build_real (rettype, frac_rvt);
9355           exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9356         }
9357         break;
9358       default:
9359         gcc_unreachable ();
9360       }
9361
9362       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9363       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9364       TREE_SIDE_EFFECTS (arg1) = 1;
9365       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9366     }
9367
9368   return NULL_TREE;
9369 }
9370
9371 /* Fold a call to builtin ldexp or scalbn/scalbln.  If LDEXP is true
9372    then we can assume the base is two.  If it's false, then we have to
9373    check the mode of the TYPE parameter in certain cases.  */
9374
9375 static tree
9376 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9377                             tree type, bool ldexp)
9378 {
9379   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9380     {
9381       STRIP_NOPS (arg0);
9382       STRIP_NOPS (arg1);
9383
9384       /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0.  */
9385       if (real_zerop (arg0) || integer_zerop (arg1)
9386           || (TREE_CODE (arg0) == REAL_CST
9387               && !real_isfinite (&TREE_REAL_CST (arg0))))
9388         return omit_one_operand_loc (loc, type, arg0, arg1);
9389
9390       /* If both arguments are constant, then try to evaluate it.  */
9391       if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9392           && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9393           && host_integerp (arg1, 0))
9394         {
9395           /* Bound the maximum adjustment to twice the range of the
9396              mode's valid exponents.  Use abs to ensure the range is
9397              positive as a sanity check.  */
9398           const long max_exp_adj = 2 *
9399             labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9400                  - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9401
9402           /* Get the user-requested adjustment.  */
9403           const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9404
9405           /* The requested adjustment must be inside this range.  This
9406              is a preliminary cap to avoid things like overflow, we
9407              may still fail to compute the result for other reasons.  */
9408           if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9409             {
9410               REAL_VALUE_TYPE initial_result;
9411
9412               real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9413
9414               /* Ensure we didn't overflow.  */
9415               if (! real_isinf (&initial_result))
9416                 {
9417                   const REAL_VALUE_TYPE trunc_result
9418                     = real_value_truncate (TYPE_MODE (type), initial_result);
9419
9420                   /* Only proceed if the target mode can hold the
9421                      resulting value.  */
9422                   if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9423                     return build_real (type, trunc_result);
9424                 }
9425             }
9426         }
9427     }
9428
9429   return NULL_TREE;
9430 }
9431
9432 /* Fold a call to builtin modf.  */
9433
9434 static tree
9435 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9436 {
9437   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9438     return NULL_TREE;
9439
9440   STRIP_NOPS (arg0);
9441
9442   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9443     return NULL_TREE;
9444
9445   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9446
9447   /* Proceed if a valid pointer type was passed in.  */
9448   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9449     {
9450       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9451       REAL_VALUE_TYPE trunc, frac;
9452
9453       switch (value->cl)
9454       {
9455       case rvc_nan:
9456       case rvc_zero:
9457         /* For +-NaN or +-0, return (*arg1 = arg0, arg0).  */
9458         trunc = frac = *value;
9459         break;
9460       case rvc_inf:
9461         /* For +-Inf, return (*arg1 = arg0, +-0).  */
9462         frac = dconst0;
9463         frac.sign = value->sign;
9464         trunc = *value;
9465         break;
9466       case rvc_normal:
9467         /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)).  */
9468         real_trunc (&trunc, VOIDmode, value);
9469         real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9470         /* If the original number was negative and already
9471            integral, then the fractional part is -0.0.  */
9472         if (value->sign && frac.cl == rvc_zero)
9473           frac.sign = value->sign;
9474         break;
9475       }
9476
9477       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9478       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9479                           build_real (rettype, trunc));
9480       TREE_SIDE_EFFECTS (arg1) = 1;
9481       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9482                           build_real (rettype, frac));
9483     }
9484
9485   return NULL_TREE;
9486 }
9487
9488 /* Given a location LOC, an interclass builtin function decl FNDECL
9489    and its single argument ARG, return an folded expression computing
9490    the same, or NULL_TREE if we either couldn't or didn't want to fold
9491    (the latter happen if there's an RTL instruction available).  */
9492
9493 static tree
9494 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9495 {
9496   enum machine_mode mode;
9497
9498   if (!validate_arg (arg, REAL_TYPE))
9499     return NULL_TREE;
9500
9501   if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9502     return NULL_TREE;
9503
9504   mode = TYPE_MODE (TREE_TYPE (arg));
9505
9506   /* If there is no optab, try generic code.  */
9507   switch (DECL_FUNCTION_CODE (fndecl))
9508     {
9509       tree result;
9510
9511     CASE_FLT_FN (BUILT_IN_ISINF):
9512       {
9513         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
9514         tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
9515         tree const type = TREE_TYPE (arg);
9516         REAL_VALUE_TYPE r;
9517         char buf[128];
9518
9519         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9520         real_from_string (&r, buf);
9521         result = build_call_expr (isgr_fn, 2,
9522                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9523                                   build_real (type, r));
9524         return result;
9525       }
9526     CASE_FLT_FN (BUILT_IN_FINITE):
9527     case BUILT_IN_ISFINITE:
9528       {
9529         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
9530         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9531         tree const type = TREE_TYPE (arg);
9532         REAL_VALUE_TYPE r;
9533         char buf[128];
9534
9535         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9536         real_from_string (&r, buf);
9537         result = build_call_expr (isle_fn, 2,
9538                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9539                                   build_real (type, r));
9540         /*result = fold_build2_loc (loc, UNGT_EXPR,
9541                                   TREE_TYPE (TREE_TYPE (fndecl)),
9542                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9543                                   build_real (type, r));
9544         result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9545                                   TREE_TYPE (TREE_TYPE (fndecl)),
9546                                   result);*/
9547         return result;
9548       }
9549     case BUILT_IN_ISNORMAL:
9550       {
9551         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9552            islessequal(fabs(x),DBL_MAX).  */
9553         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9554         tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
9555         tree const type = TREE_TYPE (arg);
9556         REAL_VALUE_TYPE rmax, rmin;
9557         char buf[128];
9558
9559         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9560         real_from_string (&rmax, buf);
9561         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9562         real_from_string (&rmin, buf);
9563         arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9564         result = build_call_expr (isle_fn, 2, arg,
9565                                   build_real (type, rmax));
9566         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
9567                               build_call_expr (isge_fn, 2, arg,
9568                                                build_real (type, rmin)));
9569         return result;
9570       }
9571     default:
9572       break;
9573     }
9574
9575   return NULL_TREE;
9576 }
9577
9578 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9579    ARG is the argument for the call.  */
9580
9581 static tree
9582 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
9583 {
9584   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9585   REAL_VALUE_TYPE r;
9586
9587   if (!validate_arg (arg, REAL_TYPE))
9588     return NULL_TREE;
9589
9590   switch (builtin_index)
9591     {
9592     case BUILT_IN_ISINF:
9593       if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9594         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9595
9596       if (TREE_CODE (arg) == REAL_CST)
9597         {
9598           r = TREE_REAL_CST (arg);
9599           if (real_isinf (&r))
9600             return real_compare (GT_EXPR, &r, &dconst0)
9601                    ? integer_one_node : integer_minus_one_node;
9602           else
9603             return integer_zero_node;
9604         }
9605
9606       return NULL_TREE;
9607
9608     case BUILT_IN_ISINF_SIGN:
9609       {
9610         /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9611         /* In a boolean context, GCC will fold the inner COND_EXPR to
9612            1.  So e.g. "if (isinf_sign(x))" would be folded to just
9613            "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9614         tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
9615         tree isinf_fn = built_in_decls[BUILT_IN_ISINF];
9616         tree tmp = NULL_TREE;
9617
9618         arg = builtin_save_expr (arg);
9619
9620         if (signbit_fn && isinf_fn)
9621           {
9622             tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
9623             tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
9624
9625             signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9626                                         signbit_call, integer_zero_node);
9627             isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9628                                       isinf_call, integer_zero_node);
9629
9630             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
9631                                integer_minus_one_node, integer_one_node);
9632             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9633                                isinf_call, tmp,
9634                                integer_zero_node);
9635           }
9636
9637         return tmp;
9638       }
9639
9640     case BUILT_IN_ISFINITE:
9641       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
9642           && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9643         return omit_one_operand_loc (loc, type, integer_one_node, arg);
9644
9645       if (TREE_CODE (arg) == REAL_CST)
9646         {
9647           r = TREE_REAL_CST (arg);
9648           return real_isfinite (&r) ? integer_one_node : integer_zero_node;
9649         }
9650
9651       return NULL_TREE;
9652
9653     case BUILT_IN_ISNAN:
9654       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
9655         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9656
9657       if (TREE_CODE (arg) == REAL_CST)
9658         {
9659           r = TREE_REAL_CST (arg);
9660           return real_isnan (&r) ? integer_one_node : integer_zero_node;
9661         }
9662
9663       arg = builtin_save_expr (arg);
9664       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
9665
9666     default:
9667       gcc_unreachable ();
9668     }
9669 }
9670
9671 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9672    This builtin will generate code to return the appropriate floating
9673    point classification depending on the value of the floating point
9674    number passed in.  The possible return values must be supplied as
9675    int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9676    FP_NORMAL, FP_SUBNORMAL and FP_ZERO.  The ellipses is for exactly
9677    one floating point argument which is "type generic".  */
9678
9679 static tree
9680 fold_builtin_fpclassify (location_t loc, tree exp)
9681 {
9682   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
9683     arg, type, res, tmp;
9684   enum machine_mode mode;
9685   REAL_VALUE_TYPE r;
9686   char buf[128];
9687
9688   /* Verify the required arguments in the original call.  */
9689   if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
9690                          INTEGER_TYPE, INTEGER_TYPE,
9691                          INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
9692     return NULL_TREE;
9693
9694   fp_nan = CALL_EXPR_ARG (exp, 0);
9695   fp_infinite = CALL_EXPR_ARG (exp, 1);
9696   fp_normal = CALL_EXPR_ARG (exp, 2);
9697   fp_subnormal = CALL_EXPR_ARG (exp, 3);
9698   fp_zero = CALL_EXPR_ARG (exp, 4);
9699   arg = CALL_EXPR_ARG (exp, 5);
9700   type = TREE_TYPE (arg);
9701   mode = TYPE_MODE (type);
9702   arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9703
9704   /* fpclassify(x) ->
9705        isnan(x) ? FP_NAN :
9706          (fabs(x) == Inf ? FP_INFINITE :
9707            (fabs(x) >= DBL_MIN ? FP_NORMAL :
9708              (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
9709
9710   tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9711                      build_real (type, dconst0));
9712   res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9713                      tmp, fp_zero, fp_subnormal);
9714
9715   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9716   real_from_string (&r, buf);
9717   tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
9718                      arg, build_real (type, r));
9719   res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
9720
9721   if (HONOR_INFINITIES (mode))
9722     {
9723       real_inf (&r);
9724       tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9725                          build_real (type, r));
9726       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
9727                          fp_infinite, res);
9728     }
9729
9730   if (HONOR_NANS (mode))
9731     {
9732       tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
9733       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
9734     }
9735
9736   return res;
9737 }
9738
9739 /* Fold a call to an unordered comparison function such as
9740    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
9741    being called and ARG0 and ARG1 are the arguments for the call.
9742    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9743    the opposite of the desired result.  UNORDERED_CODE is used
9744    for modes that can hold NaNs and ORDERED_CODE is used for
9745    the rest.  */
9746
9747 static tree
9748 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
9749                             enum tree_code unordered_code,
9750                             enum tree_code ordered_code)
9751 {
9752   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9753   enum tree_code code;
9754   tree type0, type1;
9755   enum tree_code code0, code1;
9756   tree cmp_type = NULL_TREE;
9757
9758   type0 = TREE_TYPE (arg0);
9759   type1 = TREE_TYPE (arg1);
9760
9761   code0 = TREE_CODE (type0);
9762   code1 = TREE_CODE (type1);
9763
9764   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
9765     /* Choose the wider of two real types.  */
9766     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
9767       ? type0 : type1;
9768   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
9769     cmp_type = type0;
9770   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
9771     cmp_type = type1;
9772
9773   arg0 = fold_convert_loc (loc, cmp_type, arg0);
9774   arg1 = fold_convert_loc (loc, cmp_type, arg1);
9775
9776   if (unordered_code == UNORDERED_EXPR)
9777     {
9778       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9779         return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
9780       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
9781     }
9782
9783   code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
9784                                                    : ordered_code;
9785   return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
9786                       fold_build2_loc (loc, code, type, arg0, arg1));
9787 }
9788
9789 /* Fold a call to built-in function FNDECL with 0 arguments.
9790    IGNORE is true if the result of the function call is ignored.  This
9791    function returns NULL_TREE if no simplification was possible.  */
9792
9793 static tree
9794 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
9795 {
9796   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9797   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9798   switch (fcode)
9799     {
9800     CASE_FLT_FN (BUILT_IN_INF):
9801     case BUILT_IN_INFD32:
9802     case BUILT_IN_INFD64:
9803     case BUILT_IN_INFD128:
9804       return fold_builtin_inf (loc, type, true);
9805
9806     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
9807       return fold_builtin_inf (loc, type, false);
9808
9809     case BUILT_IN_CLASSIFY_TYPE:
9810       return fold_builtin_classify_type (NULL_TREE);
9811
9812     default:
9813       break;
9814     }
9815   return NULL_TREE;
9816 }
9817
9818 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9819    IGNORE is true if the result of the function call is ignored.  This
9820    function returns NULL_TREE if no simplification was possible.  */
9821
9822 static tree
9823 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
9824 {
9825   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9826   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9827   switch (fcode)
9828     {
9829     case BUILT_IN_CONSTANT_P:
9830       {
9831         tree val = fold_builtin_constant_p (arg0);
9832
9833         /* Gimplification will pull the CALL_EXPR for the builtin out of
9834            an if condition.  When not optimizing, we'll not CSE it back.
9835            To avoid link error types of regressions, return false now.  */
9836         if (!val && !optimize)
9837           val = integer_zero_node;
9838
9839         return val;
9840       }
9841
9842     case BUILT_IN_CLASSIFY_TYPE:
9843       return fold_builtin_classify_type (arg0);
9844
9845     case BUILT_IN_STRLEN:
9846       return fold_builtin_strlen (loc, type, arg0);
9847
9848     CASE_FLT_FN (BUILT_IN_FABS):
9849       return fold_builtin_fabs (loc, arg0, type);
9850
9851     case BUILT_IN_ABS:
9852     case BUILT_IN_LABS:
9853     case BUILT_IN_LLABS:
9854     case BUILT_IN_IMAXABS:
9855       return fold_builtin_abs (loc, arg0, type);
9856
9857     CASE_FLT_FN (BUILT_IN_CONJ):
9858       if (validate_arg (arg0, COMPLEX_TYPE)
9859         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9860         return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
9861     break;
9862
9863     CASE_FLT_FN (BUILT_IN_CREAL):
9864       if (validate_arg (arg0, COMPLEX_TYPE)
9865         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9866         return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
9867     break;
9868
9869     CASE_FLT_FN (BUILT_IN_CIMAG):
9870       if (validate_arg (arg0, COMPLEX_TYPE)
9871           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9872         return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
9873     break;
9874
9875     CASE_FLT_FN (BUILT_IN_CCOS):
9876       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
9877
9878     CASE_FLT_FN (BUILT_IN_CCOSH):
9879       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
9880
9881     CASE_FLT_FN (BUILT_IN_CPROJ):
9882       return fold_builtin_cproj(loc, arg0, type);
9883
9884     CASE_FLT_FN (BUILT_IN_CSIN):
9885       if (validate_arg (arg0, COMPLEX_TYPE)
9886           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9887         return do_mpc_arg1 (arg0, type, mpc_sin);
9888     break;
9889
9890     CASE_FLT_FN (BUILT_IN_CSINH):
9891       if (validate_arg (arg0, COMPLEX_TYPE)
9892           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9893         return do_mpc_arg1 (arg0, type, mpc_sinh);
9894     break;
9895
9896     CASE_FLT_FN (BUILT_IN_CTAN):
9897       if (validate_arg (arg0, COMPLEX_TYPE)
9898           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9899         return do_mpc_arg1 (arg0, type, mpc_tan);
9900     break;
9901
9902     CASE_FLT_FN (BUILT_IN_CTANH):
9903       if (validate_arg (arg0, COMPLEX_TYPE)
9904           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9905         return do_mpc_arg1 (arg0, type, mpc_tanh);
9906     break;
9907
9908     CASE_FLT_FN (BUILT_IN_CLOG):
9909       if (validate_arg (arg0, COMPLEX_TYPE)
9910           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9911         return do_mpc_arg1 (arg0, type, mpc_log);
9912     break;
9913
9914     CASE_FLT_FN (BUILT_IN_CSQRT):
9915       if (validate_arg (arg0, COMPLEX_TYPE)
9916           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9917         return do_mpc_arg1 (arg0, type, mpc_sqrt);
9918     break;
9919
9920     CASE_FLT_FN (BUILT_IN_CASIN):
9921       if (validate_arg (arg0, COMPLEX_TYPE)
9922           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9923         return do_mpc_arg1 (arg0, type, mpc_asin);
9924     break;
9925
9926     CASE_FLT_FN (BUILT_IN_CACOS):
9927       if (validate_arg (arg0, COMPLEX_TYPE)
9928           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9929         return do_mpc_arg1 (arg0, type, mpc_acos);
9930     break;
9931
9932     CASE_FLT_FN (BUILT_IN_CATAN):
9933       if (validate_arg (arg0, COMPLEX_TYPE)
9934           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9935         return do_mpc_arg1 (arg0, type, mpc_atan);
9936     break;
9937
9938     CASE_FLT_FN (BUILT_IN_CASINH):
9939       if (validate_arg (arg0, COMPLEX_TYPE)
9940           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9941         return do_mpc_arg1 (arg0, type, mpc_asinh);
9942     break;
9943
9944     CASE_FLT_FN (BUILT_IN_CACOSH):
9945       if (validate_arg (arg0, COMPLEX_TYPE)
9946           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9947         return do_mpc_arg1 (arg0, type, mpc_acosh);
9948     break;
9949
9950     CASE_FLT_FN (BUILT_IN_CATANH):
9951       if (validate_arg (arg0, COMPLEX_TYPE)
9952           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9953         return do_mpc_arg1 (arg0, type, mpc_atanh);
9954     break;
9955
9956     CASE_FLT_FN (BUILT_IN_CABS):
9957       return fold_builtin_cabs (loc, arg0, type, fndecl);
9958
9959     CASE_FLT_FN (BUILT_IN_CARG):
9960       return fold_builtin_carg (loc, arg0, type);
9961
9962     CASE_FLT_FN (BUILT_IN_SQRT):
9963       return fold_builtin_sqrt (loc, arg0, type);
9964
9965     CASE_FLT_FN (BUILT_IN_CBRT):
9966       return fold_builtin_cbrt (loc, arg0, type);
9967
9968     CASE_FLT_FN (BUILT_IN_ASIN):
9969       if (validate_arg (arg0, REAL_TYPE))
9970         return do_mpfr_arg1 (arg0, type, mpfr_asin,
9971                              &dconstm1, &dconst1, true);
9972     break;
9973
9974     CASE_FLT_FN (BUILT_IN_ACOS):
9975       if (validate_arg (arg0, REAL_TYPE))
9976         return do_mpfr_arg1 (arg0, type, mpfr_acos,
9977                              &dconstm1, &dconst1, true);
9978     break;
9979
9980     CASE_FLT_FN (BUILT_IN_ATAN):
9981       if (validate_arg (arg0, REAL_TYPE))
9982         return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
9983     break;
9984
9985     CASE_FLT_FN (BUILT_IN_ASINH):
9986       if (validate_arg (arg0, REAL_TYPE))
9987         return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
9988     break;
9989
9990     CASE_FLT_FN (BUILT_IN_ACOSH):
9991       if (validate_arg (arg0, REAL_TYPE))
9992         return do_mpfr_arg1 (arg0, type, mpfr_acosh,
9993                              &dconst1, NULL, true);
9994     break;
9995
9996     CASE_FLT_FN (BUILT_IN_ATANH):
9997       if (validate_arg (arg0, REAL_TYPE))
9998         return do_mpfr_arg1 (arg0, type, mpfr_atanh,
9999                              &dconstm1, &dconst1, false);
10000     break;
10001
10002     CASE_FLT_FN (BUILT_IN_SIN):
10003       if (validate_arg (arg0, REAL_TYPE))
10004         return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10005     break;
10006
10007     CASE_FLT_FN (BUILT_IN_COS):
10008       return fold_builtin_cos (loc, arg0, type, fndecl);
10009
10010     CASE_FLT_FN (BUILT_IN_TAN):
10011       return fold_builtin_tan (arg0, type);
10012
10013     CASE_FLT_FN (BUILT_IN_CEXP):
10014       return fold_builtin_cexp (loc, arg0, type);
10015
10016     CASE_FLT_FN (BUILT_IN_CEXPI):
10017       if (validate_arg (arg0, REAL_TYPE))
10018         return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10019     break;
10020
10021     CASE_FLT_FN (BUILT_IN_SINH):
10022       if (validate_arg (arg0, REAL_TYPE))
10023         return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10024     break;
10025
10026     CASE_FLT_FN (BUILT_IN_COSH):
10027       return fold_builtin_cosh (loc, arg0, type, fndecl);
10028
10029     CASE_FLT_FN (BUILT_IN_TANH):
10030       if (validate_arg (arg0, REAL_TYPE))
10031         return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10032     break;
10033
10034     CASE_FLT_FN (BUILT_IN_ERF):
10035       if (validate_arg (arg0, REAL_TYPE))
10036         return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10037     break;
10038
10039     CASE_FLT_FN (BUILT_IN_ERFC):
10040       if (validate_arg (arg0, REAL_TYPE))
10041         return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10042     break;
10043
10044     CASE_FLT_FN (BUILT_IN_TGAMMA):
10045       if (validate_arg (arg0, REAL_TYPE))
10046         return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10047     break;
10048
10049     CASE_FLT_FN (BUILT_IN_EXP):
10050       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10051
10052     CASE_FLT_FN (BUILT_IN_EXP2):
10053       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10054
10055     CASE_FLT_FN (BUILT_IN_EXP10):
10056     CASE_FLT_FN (BUILT_IN_POW10):
10057       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10058
10059     CASE_FLT_FN (BUILT_IN_EXPM1):
10060       if (validate_arg (arg0, REAL_TYPE))
10061         return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10062     break;
10063
10064     CASE_FLT_FN (BUILT_IN_LOG):
10065     return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10066
10067     CASE_FLT_FN (BUILT_IN_LOG2):
10068       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10069
10070     CASE_FLT_FN (BUILT_IN_LOG10):
10071       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10072
10073     CASE_FLT_FN (BUILT_IN_LOG1P):
10074       if (validate_arg (arg0, REAL_TYPE))
10075         return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10076                              &dconstm1, NULL, false);
10077     break;
10078
10079     CASE_FLT_FN (BUILT_IN_J0):
10080       if (validate_arg (arg0, REAL_TYPE))
10081         return do_mpfr_arg1 (arg0, type, mpfr_j0,
10082                              NULL, NULL, 0);
10083     break;
10084
10085     CASE_FLT_FN (BUILT_IN_J1):
10086       if (validate_arg (arg0, REAL_TYPE))
10087         return do_mpfr_arg1 (arg0, type, mpfr_j1,
10088                              NULL, NULL, 0);
10089     break;
10090
10091     CASE_FLT_FN (BUILT_IN_Y0):
10092       if (validate_arg (arg0, REAL_TYPE))
10093         return do_mpfr_arg1 (arg0, type, mpfr_y0,
10094                              &dconst0, NULL, false);
10095     break;
10096
10097     CASE_FLT_FN (BUILT_IN_Y1):
10098       if (validate_arg (arg0, REAL_TYPE))
10099         return do_mpfr_arg1 (arg0, type, mpfr_y1,
10100                              &dconst0, NULL, false);
10101     break;
10102
10103     CASE_FLT_FN (BUILT_IN_NAN):
10104     case BUILT_IN_NAND32:
10105     case BUILT_IN_NAND64:
10106     case BUILT_IN_NAND128:
10107       return fold_builtin_nan (arg0, type, true);
10108
10109     CASE_FLT_FN (BUILT_IN_NANS):
10110       return fold_builtin_nan (arg0, type, false);
10111
10112     CASE_FLT_FN (BUILT_IN_FLOOR):
10113       return fold_builtin_floor (loc, fndecl, arg0);
10114
10115     CASE_FLT_FN (BUILT_IN_CEIL):
10116       return fold_builtin_ceil (loc, fndecl, arg0);
10117
10118     CASE_FLT_FN (BUILT_IN_TRUNC):
10119       return fold_builtin_trunc (loc, fndecl, arg0);
10120
10121     CASE_FLT_FN (BUILT_IN_ROUND):
10122       return fold_builtin_round (loc, fndecl, arg0);
10123
10124     CASE_FLT_FN (BUILT_IN_NEARBYINT):
10125     CASE_FLT_FN (BUILT_IN_RINT):
10126       return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10127
10128     CASE_FLT_FN (BUILT_IN_LCEIL):
10129     CASE_FLT_FN (BUILT_IN_LLCEIL):
10130     CASE_FLT_FN (BUILT_IN_LFLOOR):
10131     CASE_FLT_FN (BUILT_IN_LLFLOOR):
10132     CASE_FLT_FN (BUILT_IN_LROUND):
10133     CASE_FLT_FN (BUILT_IN_LLROUND):
10134       return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10135
10136     CASE_FLT_FN (BUILT_IN_LRINT):
10137     CASE_FLT_FN (BUILT_IN_LLRINT):
10138       return fold_fixed_mathfn (loc, fndecl, arg0);
10139
10140     case BUILT_IN_BSWAP32:
10141     case BUILT_IN_BSWAP64:
10142       return fold_builtin_bswap (fndecl, arg0);
10143
10144     CASE_INT_FN (BUILT_IN_FFS):
10145     CASE_INT_FN (BUILT_IN_CLZ):
10146     CASE_INT_FN (BUILT_IN_CTZ):
10147     CASE_INT_FN (BUILT_IN_POPCOUNT):
10148     CASE_INT_FN (BUILT_IN_PARITY):
10149       return fold_builtin_bitop (fndecl, arg0);
10150
10151     CASE_FLT_FN (BUILT_IN_SIGNBIT):
10152       return fold_builtin_signbit (loc, arg0, type);
10153
10154     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10155       return fold_builtin_significand (loc, arg0, type);
10156
10157     CASE_FLT_FN (BUILT_IN_ILOGB):
10158     CASE_FLT_FN (BUILT_IN_LOGB):
10159       return fold_builtin_logb (loc, arg0, type);
10160
10161     case BUILT_IN_ISASCII:
10162       return fold_builtin_isascii (loc, arg0);
10163
10164     case BUILT_IN_TOASCII:
10165       return fold_builtin_toascii (loc, arg0);
10166
10167     case BUILT_IN_ISDIGIT:
10168       return fold_builtin_isdigit (loc, arg0);
10169
10170     CASE_FLT_FN (BUILT_IN_FINITE):
10171     case BUILT_IN_FINITED32:
10172     case BUILT_IN_FINITED64:
10173     case BUILT_IN_FINITED128:
10174     case BUILT_IN_ISFINITE:
10175       {
10176         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10177         if (ret)
10178           return ret;
10179         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10180       }
10181
10182     CASE_FLT_FN (BUILT_IN_ISINF):
10183     case BUILT_IN_ISINFD32:
10184     case BUILT_IN_ISINFD64:
10185     case BUILT_IN_ISINFD128:
10186       {
10187         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10188         if (ret)
10189           return ret;
10190         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10191       }
10192
10193     case BUILT_IN_ISNORMAL:
10194       return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10195
10196     case BUILT_IN_ISINF_SIGN:
10197       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10198
10199     CASE_FLT_FN (BUILT_IN_ISNAN):
10200     case BUILT_IN_ISNAND32:
10201     case BUILT_IN_ISNAND64:
10202     case BUILT_IN_ISNAND128:
10203       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10204
10205     case BUILT_IN_PRINTF:
10206     case BUILT_IN_PRINTF_UNLOCKED:
10207     case BUILT_IN_VPRINTF:
10208       return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10209
10210     case BUILT_IN_FREE:
10211       if (integer_zerop (arg0))
10212         return build_empty_stmt (loc);
10213       break;
10214
10215     default:
10216       break;
10217     }
10218
10219   return NULL_TREE;
10220
10221 }
10222
10223 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10224    IGNORE is true if the result of the function call is ignored.  This
10225    function returns NULL_TREE if no simplification was possible.  */
10226
10227 static tree
10228 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10229 {
10230   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10231   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10232
10233   switch (fcode)
10234     {
10235     CASE_FLT_FN (BUILT_IN_JN):
10236       if (validate_arg (arg0, INTEGER_TYPE)
10237           && validate_arg (arg1, REAL_TYPE))
10238         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10239     break;
10240
10241     CASE_FLT_FN (BUILT_IN_YN):
10242       if (validate_arg (arg0, INTEGER_TYPE)
10243           && validate_arg (arg1, REAL_TYPE))
10244         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10245                                  &dconst0, false);
10246     break;
10247
10248     CASE_FLT_FN (BUILT_IN_DREM):
10249     CASE_FLT_FN (BUILT_IN_REMAINDER):
10250       if (validate_arg (arg0, REAL_TYPE)
10251           && validate_arg(arg1, REAL_TYPE))
10252         return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10253     break;
10254
10255     CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10256     CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10257       if (validate_arg (arg0, REAL_TYPE)
10258           && validate_arg(arg1, POINTER_TYPE))
10259         return do_mpfr_lgamma_r (arg0, arg1, type);
10260     break;
10261
10262     CASE_FLT_FN (BUILT_IN_ATAN2):
10263       if (validate_arg (arg0, REAL_TYPE)
10264           && validate_arg(arg1, REAL_TYPE))
10265         return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10266     break;
10267
10268     CASE_FLT_FN (BUILT_IN_FDIM):
10269       if (validate_arg (arg0, REAL_TYPE)
10270           && validate_arg(arg1, REAL_TYPE))
10271         return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10272     break;
10273
10274     CASE_FLT_FN (BUILT_IN_HYPOT):
10275       return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10276
10277     CASE_FLT_FN (BUILT_IN_CPOW):
10278       if (validate_arg (arg0, COMPLEX_TYPE)
10279           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10280           && validate_arg (arg1, COMPLEX_TYPE)
10281           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10282         return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10283     break;
10284
10285     CASE_FLT_FN (BUILT_IN_LDEXP):
10286       return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10287     CASE_FLT_FN (BUILT_IN_SCALBN):
10288     CASE_FLT_FN (BUILT_IN_SCALBLN):
10289       return fold_builtin_load_exponent (loc, arg0, arg1,
10290                                          type, /*ldexp=*/false);
10291
10292     CASE_FLT_FN (BUILT_IN_FREXP):
10293       return fold_builtin_frexp (loc, arg0, arg1, type);
10294
10295     CASE_FLT_FN (BUILT_IN_MODF):
10296       return fold_builtin_modf (loc, arg0, arg1, type);
10297
10298     case BUILT_IN_BZERO:
10299       return fold_builtin_bzero (loc, arg0, arg1, ignore);
10300
10301     case BUILT_IN_FPUTS:
10302       return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10303
10304     case BUILT_IN_FPUTS_UNLOCKED:
10305       return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10306
10307     case BUILT_IN_STRSTR:
10308       return fold_builtin_strstr (loc, arg0, arg1, type);
10309
10310     case BUILT_IN_STRCAT:
10311       return fold_builtin_strcat (loc, arg0, arg1);
10312
10313     case BUILT_IN_STRSPN:
10314       return fold_builtin_strspn (loc, arg0, arg1);
10315
10316     case BUILT_IN_STRCSPN:
10317       return fold_builtin_strcspn (loc, arg0, arg1);
10318
10319     case BUILT_IN_STRCHR:
10320     case BUILT_IN_INDEX:
10321       return fold_builtin_strchr (loc, arg0, arg1, type);
10322
10323     case BUILT_IN_STRRCHR:
10324     case BUILT_IN_RINDEX:
10325       return fold_builtin_strrchr (loc, arg0, arg1, type);
10326
10327     case BUILT_IN_STRCPY:
10328       return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10329
10330     case BUILT_IN_STPCPY:
10331       if (ignore)
10332         {
10333           tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
10334           if (!fn)
10335             break;
10336
10337           return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10338         }
10339       else
10340         return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10341       break;
10342
10343     case BUILT_IN_STRCMP:
10344       return fold_builtin_strcmp (loc, arg0, arg1);
10345
10346     case BUILT_IN_STRPBRK:
10347       return fold_builtin_strpbrk (loc, arg0, arg1, type);
10348
10349     case BUILT_IN_EXPECT:
10350       return fold_builtin_expect (loc, arg0, arg1);
10351
10352     CASE_FLT_FN (BUILT_IN_POW):
10353       return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10354
10355     CASE_FLT_FN (BUILT_IN_POWI):
10356       return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10357
10358     CASE_FLT_FN (BUILT_IN_COPYSIGN):
10359       return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10360
10361     CASE_FLT_FN (BUILT_IN_FMIN):
10362       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10363
10364     CASE_FLT_FN (BUILT_IN_FMAX):
10365       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10366
10367     case BUILT_IN_ISGREATER:
10368       return fold_builtin_unordered_cmp (loc, fndecl,
10369                                          arg0, arg1, UNLE_EXPR, LE_EXPR);
10370     case BUILT_IN_ISGREATEREQUAL:
10371       return fold_builtin_unordered_cmp (loc, fndecl,
10372                                          arg0, arg1, UNLT_EXPR, LT_EXPR);
10373     case BUILT_IN_ISLESS:
10374       return fold_builtin_unordered_cmp (loc, fndecl,
10375                                          arg0, arg1, UNGE_EXPR, GE_EXPR);
10376     case BUILT_IN_ISLESSEQUAL:
10377       return fold_builtin_unordered_cmp (loc, fndecl,
10378                                          arg0, arg1, UNGT_EXPR, GT_EXPR);
10379     case BUILT_IN_ISLESSGREATER:
10380       return fold_builtin_unordered_cmp (loc, fndecl,
10381                                          arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10382     case BUILT_IN_ISUNORDERED:
10383       return fold_builtin_unordered_cmp (loc, fndecl,
10384                                          arg0, arg1, UNORDERED_EXPR,
10385                                          NOP_EXPR);
10386
10387       /* We do the folding for va_start in the expander.  */
10388     case BUILT_IN_VA_START:
10389       break;
10390
10391     case BUILT_IN_SPRINTF:
10392       return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10393
10394     case BUILT_IN_OBJECT_SIZE:
10395       return fold_builtin_object_size (arg0, arg1);
10396
10397     case BUILT_IN_PRINTF:
10398     case BUILT_IN_PRINTF_UNLOCKED:
10399     case BUILT_IN_VPRINTF:
10400       return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10401
10402     case BUILT_IN_PRINTF_CHK:
10403     case BUILT_IN_VPRINTF_CHK:
10404       if (!validate_arg (arg0, INTEGER_TYPE)
10405           || TREE_SIDE_EFFECTS (arg0))
10406         return NULL_TREE;
10407       else
10408         return fold_builtin_printf (loc, fndecl,
10409                                     arg1, NULL_TREE, ignore, fcode);
10410     break;
10411
10412     case BUILT_IN_FPRINTF:
10413     case BUILT_IN_FPRINTF_UNLOCKED:
10414     case BUILT_IN_VFPRINTF:
10415       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10416                                    ignore, fcode);
10417
10418     default:
10419       break;
10420     }
10421   return NULL_TREE;
10422 }
10423
10424 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10425    and ARG2.  IGNORE is true if the result of the function call is ignored.
10426    This function returns NULL_TREE if no simplification was possible.  */
10427
10428 static tree
10429 fold_builtin_3 (location_t loc, tree fndecl,
10430                 tree arg0, tree arg1, tree arg2, bool ignore)
10431 {
10432   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10433   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10434   switch (fcode)
10435     {
10436
10437     CASE_FLT_FN (BUILT_IN_SINCOS):
10438       return fold_builtin_sincos (loc, arg0, arg1, arg2);
10439
10440     CASE_FLT_FN (BUILT_IN_FMA):
10441       if (validate_arg (arg0, REAL_TYPE)
10442           && validate_arg(arg1, REAL_TYPE)
10443           && validate_arg(arg2, REAL_TYPE))
10444         return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
10445     break;
10446
10447     CASE_FLT_FN (BUILT_IN_REMQUO):
10448       if (validate_arg (arg0, REAL_TYPE)
10449           && validate_arg(arg1, REAL_TYPE)
10450           && validate_arg(arg2, POINTER_TYPE))
10451         return do_mpfr_remquo (arg0, arg1, arg2);
10452     break;
10453
10454     case BUILT_IN_MEMSET:
10455       return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10456
10457     case BUILT_IN_BCOPY:
10458       return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10459                                      void_type_node, true, /*endp=*/3);
10460
10461     case BUILT_IN_MEMCPY:
10462       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10463                                      type, ignore, /*endp=*/0);
10464
10465     case BUILT_IN_MEMPCPY:
10466       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10467                                      type, ignore, /*endp=*/1);
10468
10469     case BUILT_IN_MEMMOVE:
10470       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10471                                      type, ignore, /*endp=*/3);
10472
10473     case BUILT_IN_STRNCAT:
10474       return fold_builtin_strncat (loc, arg0, arg1, arg2);
10475
10476     case BUILT_IN_STRNCPY:
10477       return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10478
10479     case BUILT_IN_STRNCMP:
10480       return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10481
10482     case BUILT_IN_MEMCHR:
10483       return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10484
10485     case BUILT_IN_BCMP:
10486     case BUILT_IN_MEMCMP:
10487       return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10488
10489     case BUILT_IN_SPRINTF:
10490       return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10491
10492     case BUILT_IN_STRCPY_CHK:
10493     case BUILT_IN_STPCPY_CHK:
10494       return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10495                                       ignore, fcode);
10496
10497     case BUILT_IN_STRCAT_CHK:
10498       return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10499
10500     case BUILT_IN_PRINTF_CHK:
10501     case BUILT_IN_VPRINTF_CHK:
10502       if (!validate_arg (arg0, INTEGER_TYPE)
10503           || TREE_SIDE_EFFECTS (arg0))
10504         return NULL_TREE;
10505       else
10506         return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10507     break;
10508
10509     case BUILT_IN_FPRINTF:
10510     case BUILT_IN_FPRINTF_UNLOCKED:
10511     case BUILT_IN_VFPRINTF:
10512       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10513                                    ignore, fcode);
10514
10515     case BUILT_IN_FPRINTF_CHK:
10516     case BUILT_IN_VFPRINTF_CHK:
10517       if (!validate_arg (arg1, INTEGER_TYPE)
10518           || TREE_SIDE_EFFECTS (arg1))
10519         return NULL_TREE;
10520       else
10521         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10522                                      ignore, fcode);
10523
10524     default:
10525       break;
10526     }
10527   return NULL_TREE;
10528 }
10529
10530 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10531    ARG2, and ARG3.  IGNORE is true if the result of the function call is
10532    ignored.  This function returns NULL_TREE if no simplification was
10533    possible.  */
10534
10535 static tree
10536 fold_builtin_4 (location_t loc, tree fndecl,
10537                 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10538 {
10539   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10540
10541   switch (fcode)
10542     {
10543     case BUILT_IN_MEMCPY_CHK:
10544     case BUILT_IN_MEMPCPY_CHK:
10545     case BUILT_IN_MEMMOVE_CHK:
10546     case BUILT_IN_MEMSET_CHK:
10547       return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10548                                       NULL_TREE, ignore,
10549                                       DECL_FUNCTION_CODE (fndecl));
10550
10551     case BUILT_IN_STRNCPY_CHK:
10552       return fold_builtin_strncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE);
10553
10554     case BUILT_IN_STRNCAT_CHK:
10555       return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
10556
10557     case BUILT_IN_FPRINTF_CHK:
10558     case BUILT_IN_VFPRINTF_CHK:
10559       if (!validate_arg (arg1, INTEGER_TYPE)
10560           || TREE_SIDE_EFFECTS (arg1))
10561         return NULL_TREE;
10562       else
10563         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
10564                                      ignore, fcode);
10565     break;
10566
10567     default:
10568       break;
10569     }
10570   return NULL_TREE;
10571 }
10572
10573 /* Fold a call to built-in function FNDECL.  ARGS is an array of NARGS
10574     arguments, where NARGS <= 4.  IGNORE is true if the result of the
10575     function call is ignored.  This function returns NULL_TREE if no
10576     simplification was possible.  Note that this only folds builtins with
10577     fixed argument patterns.  Foldings that do varargs-to-varargs
10578     transformations, or that match calls with more than 4 arguments,
10579     need to be handled with fold_builtin_varargs instead.  */
10580
10581 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10582
10583 static tree
10584 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
10585 {
10586   tree ret = NULL_TREE;
10587
10588   switch (nargs)
10589     {
10590     case 0:
10591       ret = fold_builtin_0 (loc, fndecl, ignore);
10592       break;
10593     case 1:
10594       ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
10595       break;
10596     case 2:
10597       ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
10598       break;
10599     case 3:
10600       ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
10601       break;
10602     case 4:
10603       ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
10604                             ignore);
10605       break;
10606     default:
10607       break;
10608     }
10609   if (ret)
10610     {
10611       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10612       SET_EXPR_LOCATION (ret, loc);
10613       TREE_NO_WARNING (ret) = 1;
10614       return ret;
10615     }
10616   return NULL_TREE;
10617 }
10618
10619 /* Builtins with folding operations that operate on "..." arguments
10620    need special handling; we need to store the arguments in a convenient
10621    data structure before attempting any folding.  Fortunately there are
10622    only a few builtins that fall into this category.  FNDECL is the
10623    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10624    result of the function call is ignored.  */
10625
10626 static tree
10627 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
10628                       bool ignore ATTRIBUTE_UNUSED)
10629 {
10630   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10631   tree ret = NULL_TREE;
10632
10633   switch (fcode)
10634     {
10635     case BUILT_IN_SPRINTF_CHK:
10636     case BUILT_IN_VSPRINTF_CHK:
10637       ret = fold_builtin_sprintf_chk (loc, exp, fcode);
10638       break;
10639
10640     case BUILT_IN_SNPRINTF_CHK:
10641     case BUILT_IN_VSNPRINTF_CHK:
10642       ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
10643       break;
10644
10645     case BUILT_IN_FPCLASSIFY:
10646       ret = fold_builtin_fpclassify (loc, exp);
10647       break;
10648
10649     default:
10650       break;
10651     }
10652   if (ret)
10653     {
10654       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10655       SET_EXPR_LOCATION (ret, loc);
10656       TREE_NO_WARNING (ret) = 1;
10657       return ret;
10658     }
10659   return NULL_TREE;
10660 }
10661
10662 /* Return true if FNDECL shouldn't be folded right now.
10663    If a built-in function has an inline attribute always_inline
10664    wrapper, defer folding it after always_inline functions have
10665    been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10666    might not be performed.  */
10667
10668 static bool
10669 avoid_folding_inline_builtin (tree fndecl)
10670 {
10671   return (DECL_DECLARED_INLINE_P (fndecl)
10672           && DECL_DISREGARD_INLINE_LIMITS (fndecl)
10673           && cfun
10674           && !cfun->always_inline_functions_inlined
10675           && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
10676 }
10677
10678 /* A wrapper function for builtin folding that prevents warnings for
10679    "statement without effect" and the like, caused by removing the
10680    call node earlier than the warning is generated.  */
10681
10682 tree
10683 fold_call_expr (location_t loc, tree exp, bool ignore)
10684 {
10685   tree ret = NULL_TREE;
10686   tree fndecl = get_callee_fndecl (exp);
10687   if (fndecl
10688       && TREE_CODE (fndecl) == FUNCTION_DECL
10689       && DECL_BUILT_IN (fndecl)
10690       /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10691          yet.  Defer folding until we see all the arguments
10692          (after inlining).  */
10693       && !CALL_EXPR_VA_ARG_PACK (exp))
10694     {
10695       int nargs = call_expr_nargs (exp);
10696
10697       /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10698          instead last argument is __builtin_va_arg_pack ().  Defer folding
10699          even in that case, until arguments are finalized.  */
10700       if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
10701         {
10702           tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
10703           if (fndecl2
10704               && TREE_CODE (fndecl2) == FUNCTION_DECL
10705               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10706               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10707             return NULL_TREE;
10708         }
10709
10710       if (avoid_folding_inline_builtin (fndecl))
10711         return NULL_TREE;
10712
10713       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10714         return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
10715                                      CALL_EXPR_ARGP (exp), ignore);
10716       else
10717         {
10718           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
10719             {
10720               tree *args = CALL_EXPR_ARGP (exp);
10721               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
10722             }
10723           if (!ret)
10724             ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
10725           if (ret)
10726             return ret;
10727         }
10728     }
10729   return NULL_TREE;
10730 }
10731
10732 /* Conveniently construct a function call expression.  FNDECL names the
10733    function to be called and N arguments are passed in the array
10734    ARGARRAY.  */
10735
10736 tree
10737 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
10738 {
10739   tree fntype = TREE_TYPE (fndecl);
10740   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10741
10742   return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10743 }
10744
10745 /* Conveniently construct a function call expression.  FNDECL names the
10746    function to be called and the arguments are passed in the vector
10747    VEC.  */
10748
10749 tree
10750 build_call_expr_loc_vec (location_t loc, tree fndecl, VEC(tree,gc) *vec)
10751 {
10752   return build_call_expr_loc_array (loc, fndecl, VEC_length (tree, vec),
10753                                     VEC_address (tree, vec));
10754 }
10755
10756
10757 /* Conveniently construct a function call expression.  FNDECL names the
10758    function to be called, N is the number of arguments, and the "..."
10759    parameters are the argument expressions.  */
10760
10761 tree
10762 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10763 {
10764   va_list ap;
10765   tree *argarray = XALLOCAVEC (tree, n);
10766   int i;
10767
10768   va_start (ap, n);
10769   for (i = 0; i < n; i++)
10770     argarray[i] = va_arg (ap, tree);
10771   va_end (ap);
10772   return build_call_expr_loc_array (loc, fndecl, n, argarray);
10773 }
10774
10775 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...).  Duplicated because
10776    varargs macros aren't supported by all bootstrap compilers.  */
10777
10778 tree
10779 build_call_expr (tree fndecl, int n, ...)
10780 {
10781   va_list ap;
10782   tree *argarray = XALLOCAVEC (tree, n);
10783   int i;
10784
10785   va_start (ap, n);
10786   for (i = 0; i < n; i++)
10787     argarray[i] = va_arg (ap, tree);
10788   va_end (ap);
10789   return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
10790 }
10791
10792 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10793    N arguments are passed in the array ARGARRAY.  */
10794
10795 tree
10796 fold_builtin_call_array (location_t loc, tree type,
10797                          tree fn,
10798                          int n,
10799                          tree *argarray)
10800 {
10801   tree ret = NULL_TREE;
10802    tree exp;
10803
10804   if (TREE_CODE (fn) == ADDR_EXPR)
10805   {
10806     tree fndecl = TREE_OPERAND (fn, 0);
10807     if (TREE_CODE (fndecl) == FUNCTION_DECL
10808         && DECL_BUILT_IN (fndecl))
10809       {
10810         /* If last argument is __builtin_va_arg_pack (), arguments to this
10811            function are not finalized yet.  Defer folding until they are.  */
10812         if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
10813           {
10814             tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
10815             if (fndecl2
10816                 && TREE_CODE (fndecl2) == FUNCTION_DECL
10817                 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10818                 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10819               return build_call_array_loc (loc, type, fn, n, argarray);
10820           }
10821         if (avoid_folding_inline_builtin (fndecl))
10822           return build_call_array_loc (loc, type, fn, n, argarray);
10823         if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10824           {
10825             ret = targetm.fold_builtin (fndecl, n, argarray, false);
10826             if (ret)
10827               return ret;
10828
10829             return build_call_array_loc (loc, type, fn, n, argarray);
10830           }
10831         else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
10832           {
10833             /* First try the transformations that don't require consing up
10834                an exp.  */
10835             ret = fold_builtin_n (loc, fndecl, argarray, n, false);
10836             if (ret)
10837               return ret;
10838           }
10839
10840         /* If we got this far, we need to build an exp.  */
10841         exp = build_call_array_loc (loc, type, fn, n, argarray);
10842         ret = fold_builtin_varargs (loc, fndecl, exp, false);
10843         return ret ? ret : exp;
10844       }
10845   }
10846
10847   return build_call_array_loc (loc, type, fn, n, argarray);
10848 }
10849
10850 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10851    along with N new arguments specified as the "..." parameters.  SKIP
10852    is the number of arguments in EXP to be omitted.  This function is used
10853    to do varargs-to-varargs transformations.  */
10854
10855 static tree
10856 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
10857 {
10858   int oldnargs = call_expr_nargs (exp);
10859   int nargs = oldnargs - skip + n;
10860   tree fntype = TREE_TYPE (fndecl);
10861   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10862   tree *buffer;
10863
10864   if (n > 0)
10865     {
10866       int i, j;
10867       va_list ap;
10868
10869       buffer = XALLOCAVEC (tree, nargs);
10870       va_start (ap, n);
10871       for (i = 0; i < n; i++)
10872         buffer[i] = va_arg (ap, tree);
10873       va_end (ap);
10874       for (j = skip; j < oldnargs; j++, i++)
10875         buffer[i] = CALL_EXPR_ARG (exp, j);
10876     }
10877   else
10878     buffer = CALL_EXPR_ARGP (exp) + skip;
10879
10880   return fold (build_call_array_loc (loc, TREE_TYPE (exp), fn, nargs, buffer));
10881 }
10882
10883 /* Validate a single argument ARG against a tree code CODE representing
10884    a type.  */
10885
10886 static bool
10887 validate_arg (const_tree arg, enum tree_code code)
10888 {
10889   if (!arg)
10890     return false;
10891   else if (code == POINTER_TYPE)
10892     return POINTER_TYPE_P (TREE_TYPE (arg));
10893   else if (code == INTEGER_TYPE)
10894     return INTEGRAL_TYPE_P (TREE_TYPE (arg));
10895   return code == TREE_CODE (TREE_TYPE (arg));
10896 }
10897
10898 /* This function validates the types of a function call argument list
10899    against a specified list of tree_codes.  If the last specifier is a 0,
10900    that represents an ellipses, otherwise the last specifier must be a
10901    VOID_TYPE.
10902
10903    This is the GIMPLE version of validate_arglist.  Eventually we want to
10904    completely convert builtins.c to work from GIMPLEs and the tree based
10905    validate_arglist will then be removed.  */
10906
10907 bool
10908 validate_gimple_arglist (const_gimple call, ...)
10909 {
10910   enum tree_code code;
10911   bool res = 0;
10912   va_list ap;
10913   const_tree arg;
10914   size_t i;
10915
10916   va_start (ap, call);
10917   i = 0;
10918
10919   do
10920     {
10921       code = (enum tree_code) va_arg (ap, int);
10922       switch (code)
10923         {
10924         case 0:
10925           /* This signifies an ellipses, any further arguments are all ok.  */
10926           res = true;
10927           goto end;
10928         case VOID_TYPE:
10929           /* This signifies an endlink, if no arguments remain, return
10930              true, otherwise return false.  */
10931           res = (i == gimple_call_num_args (call));
10932           goto end;
10933         default:
10934           /* If no parameters remain or the parameter's code does not
10935              match the specified code, return false.  Otherwise continue
10936              checking any remaining arguments.  */
10937           arg = gimple_call_arg (call, i++);
10938           if (!validate_arg (arg, code))
10939             goto end;
10940           break;
10941         }
10942     }
10943   while (1);
10944
10945   /* We need gotos here since we can only have one VA_CLOSE in a
10946      function.  */
10947  end: ;
10948   va_end (ap);
10949
10950   return res;
10951 }
10952
10953 /* This function validates the types of a function call argument list
10954    against a specified list of tree_codes.  If the last specifier is a 0,
10955    that represents an ellipses, otherwise the last specifier must be a
10956    VOID_TYPE.  */
10957
10958 bool
10959 validate_arglist (const_tree callexpr, ...)
10960 {
10961   enum tree_code code;
10962   bool res = 0;
10963   va_list ap;
10964   const_call_expr_arg_iterator iter;
10965   const_tree arg;
10966
10967   va_start (ap, callexpr);
10968   init_const_call_expr_arg_iterator (callexpr, &iter);
10969
10970   do
10971     {
10972       code = (enum tree_code) va_arg (ap, int);
10973       switch (code)
10974         {
10975         case 0:
10976           /* This signifies an ellipses, any further arguments are all ok.  */
10977           res = true;
10978           goto end;
10979         case VOID_TYPE:
10980           /* This signifies an endlink, if no arguments remain, return
10981              true, otherwise return false.  */
10982           res = !more_const_call_expr_args_p (&iter);
10983           goto end;
10984         default:
10985           /* If no parameters remain or the parameter's code does not
10986              match the specified code, return false.  Otherwise continue
10987              checking any remaining arguments.  */
10988           arg = next_const_call_expr_arg (&iter);
10989           if (!validate_arg (arg, code))
10990             goto end;
10991           break;
10992         }
10993     }
10994   while (1);
10995
10996   /* We need gotos here since we can only have one VA_CLOSE in a
10997      function.  */
10998  end: ;
10999   va_end (ap);
11000
11001   return res;
11002 }
11003
11004 /* Default target-specific builtin expander that does nothing.  */
11005
11006 rtx
11007 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11008                         rtx target ATTRIBUTE_UNUSED,
11009                         rtx subtarget ATTRIBUTE_UNUSED,
11010                         enum machine_mode mode ATTRIBUTE_UNUSED,
11011                         int ignore ATTRIBUTE_UNUSED)
11012 {
11013   return NULL_RTX;
11014 }
11015
11016 /* Returns true is EXP represents data that would potentially reside
11017    in a readonly section.  */
11018
11019 static bool
11020 readonly_data_expr (tree exp)
11021 {
11022   STRIP_NOPS (exp);
11023
11024   if (TREE_CODE (exp) != ADDR_EXPR)
11025     return false;
11026
11027   exp = get_base_address (TREE_OPERAND (exp, 0));
11028   if (!exp)
11029     return false;
11030
11031   /* Make sure we call decl_readonly_section only for trees it
11032      can handle (since it returns true for everything it doesn't
11033      understand).  */
11034   if (TREE_CODE (exp) == STRING_CST
11035       || TREE_CODE (exp) == CONSTRUCTOR
11036       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11037     return decl_readonly_section (exp, 0);
11038   else
11039     return false;
11040 }
11041
11042 /* Simplify a call to the strstr builtin.  S1 and S2 are the arguments
11043    to the call, and TYPE is its return type.
11044
11045    Return NULL_TREE if no simplification was possible, otherwise return the
11046    simplified form of the call as a tree.
11047
11048    The simplified form may be a constant or other expression which
11049    computes the same value, but in a more efficient manner (including
11050    calls to other builtin functions).
11051
11052    The call may contain arguments which need to be evaluated, but
11053    which are not useful to determine the result of the call.  In
11054    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11055    COMPOUND_EXPR will be an argument which must be evaluated.
11056    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11057    COMPOUND_EXPR in the chain will contain the tree for the simplified
11058    form of the builtin function call.  */
11059
11060 static tree
11061 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11062 {
11063   if (!validate_arg (s1, POINTER_TYPE)
11064       || !validate_arg (s2, POINTER_TYPE))
11065     return NULL_TREE;
11066   else
11067     {
11068       tree fn;
11069       const char *p1, *p2;
11070
11071       p2 = c_getstr (s2);
11072       if (p2 == NULL)
11073         return NULL_TREE;
11074
11075       p1 = c_getstr (s1);
11076       if (p1 != NULL)
11077         {
11078           const char *r = strstr (p1, p2);
11079           tree tem;
11080
11081           if (r == NULL)
11082             return build_int_cst (TREE_TYPE (s1), 0);
11083
11084           /* Return an offset into the constant string argument.  */
11085           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11086                              s1, size_int (r - p1));
11087           return fold_convert_loc (loc, type, tem);
11088         }
11089
11090       /* The argument is const char *, and the result is char *, so we need
11091          a type conversion here to avoid a warning.  */
11092       if (p2[0] == '\0')
11093         return fold_convert_loc (loc, type, s1);
11094
11095       if (p2[1] != '\0')
11096         return NULL_TREE;
11097
11098       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11099       if (!fn)
11100         return NULL_TREE;
11101
11102       /* New argument list transforming strstr(s1, s2) to
11103          strchr(s1, s2[0]).  */
11104       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11105     }
11106 }
11107
11108 /* Simplify a call to the strchr builtin.  S1 and S2 are the arguments to
11109    the call, and TYPE is its return type.
11110
11111    Return NULL_TREE if no simplification was possible, otherwise return the
11112    simplified form of the call as a tree.
11113
11114    The simplified form may be a constant or other expression which
11115    computes the same value, but in a more efficient manner (including
11116    calls to other builtin functions).
11117
11118    The call may contain arguments which need to be evaluated, but
11119    which are not useful to determine the result of the call.  In
11120    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11121    COMPOUND_EXPR will be an argument which must be evaluated.
11122    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11123    COMPOUND_EXPR in the chain will contain the tree for the simplified
11124    form of the builtin function call.  */
11125
11126 static tree
11127 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11128 {
11129   if (!validate_arg (s1, POINTER_TYPE)
11130       || !validate_arg (s2, INTEGER_TYPE))
11131     return NULL_TREE;
11132   else
11133     {
11134       const char *p1;
11135
11136       if (TREE_CODE (s2) != INTEGER_CST)
11137         return NULL_TREE;
11138
11139       p1 = c_getstr (s1);
11140       if (p1 != NULL)
11141         {
11142           char c;
11143           const char *r;
11144           tree tem;
11145
11146           if (target_char_cast (s2, &c))
11147             return NULL_TREE;
11148
11149           r = strchr (p1, c);
11150
11151           if (r == NULL)
11152             return build_int_cst (TREE_TYPE (s1), 0);
11153
11154           /* Return an offset into the constant string argument.  */
11155           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11156                              s1, size_int (r - p1));
11157           return fold_convert_loc (loc, type, tem);
11158         }
11159       return NULL_TREE;
11160     }
11161 }
11162
11163 /* Simplify a call to the strrchr builtin.  S1 and S2 are the arguments to
11164    the call, and TYPE is its return type.
11165
11166    Return NULL_TREE if no simplification was possible, otherwise return the
11167    simplified form of the call as a tree.
11168
11169    The simplified form may be a constant or other expression which
11170    computes the same value, but in a more efficient manner (including
11171    calls to other builtin functions).
11172
11173    The call may contain arguments which need to be evaluated, but
11174    which are not useful to determine the result of the call.  In
11175    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11176    COMPOUND_EXPR will be an argument which must be evaluated.
11177    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11178    COMPOUND_EXPR in the chain will contain the tree for the simplified
11179    form of the builtin function call.  */
11180
11181 static tree
11182 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11183 {
11184   if (!validate_arg (s1, POINTER_TYPE)
11185       || !validate_arg (s2, INTEGER_TYPE))
11186     return NULL_TREE;
11187   else
11188     {
11189       tree fn;
11190       const char *p1;
11191
11192       if (TREE_CODE (s2) != INTEGER_CST)
11193         return NULL_TREE;
11194
11195       p1 = c_getstr (s1);
11196       if (p1 != NULL)
11197         {
11198           char c;
11199           const char *r;
11200           tree tem;
11201
11202           if (target_char_cast (s2, &c))
11203             return NULL_TREE;
11204
11205           r = strrchr (p1, c);
11206
11207           if (r == NULL)
11208             return build_int_cst (TREE_TYPE (s1), 0);
11209
11210           /* Return an offset into the constant string argument.  */
11211           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11212                              s1, size_int (r - p1));
11213           return fold_convert_loc (loc, type, tem);
11214         }
11215
11216       if (! integer_zerop (s2))
11217         return NULL_TREE;
11218
11219       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11220       if (!fn)
11221         return NULL_TREE;
11222
11223       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
11224       return build_call_expr_loc (loc, fn, 2, s1, s2);
11225     }
11226 }
11227
11228 /* Simplify a call to the strpbrk builtin.  S1 and S2 are the arguments
11229    to the call, and TYPE is its return type.
11230
11231    Return NULL_TREE if no simplification was possible, otherwise return the
11232    simplified form of the call as a tree.
11233
11234    The simplified form may be a constant or other expression which
11235    computes the same value, but in a more efficient manner (including
11236    calls to other builtin functions).
11237
11238    The call may contain arguments which need to be evaluated, but
11239    which are not useful to determine the result of the call.  In
11240    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11241    COMPOUND_EXPR will be an argument which must be evaluated.
11242    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11243    COMPOUND_EXPR in the chain will contain the tree for the simplified
11244    form of the builtin function call.  */
11245
11246 static tree
11247 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11248 {
11249   if (!validate_arg (s1, POINTER_TYPE)
11250       || !validate_arg (s2, POINTER_TYPE))
11251     return NULL_TREE;
11252   else
11253     {
11254       tree fn;
11255       const char *p1, *p2;
11256
11257       p2 = c_getstr (s2);
11258       if (p2 == NULL)
11259         return NULL_TREE;
11260
11261       p1 = c_getstr (s1);
11262       if (p1 != NULL)
11263         {
11264           const char *r = strpbrk (p1, p2);
11265           tree tem;
11266
11267           if (r == NULL)
11268             return build_int_cst (TREE_TYPE (s1), 0);
11269
11270           /* Return an offset into the constant string argument.  */
11271           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11272                              s1, size_int (r - p1));
11273           return fold_convert_loc (loc, type, tem);
11274         }
11275
11276       if (p2[0] == '\0')
11277         /* strpbrk(x, "") == NULL.
11278            Evaluate and ignore s1 in case it had side-effects.  */
11279         return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11280
11281       if (p2[1] != '\0')
11282         return NULL_TREE;  /* Really call strpbrk.  */
11283
11284       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11285       if (!fn)
11286         return NULL_TREE;
11287
11288       /* New argument list transforming strpbrk(s1, s2) to
11289          strchr(s1, s2[0]).  */
11290       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11291     }
11292 }
11293
11294 /* Simplify a call to the strcat builtin.  DST and SRC are the arguments
11295    to the call.
11296
11297    Return NULL_TREE if no simplification was possible, otherwise return the
11298    simplified form of the call as a tree.
11299
11300    The simplified form may be a constant or other expression which
11301    computes the same value, but in a more efficient manner (including
11302    calls to other builtin functions).
11303
11304    The call may contain arguments which need to be evaluated, but
11305    which are not useful to determine the result of the call.  In
11306    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11307    COMPOUND_EXPR will be an argument which must be evaluated.
11308    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11309    COMPOUND_EXPR in the chain will contain the tree for the simplified
11310    form of the builtin function call.  */
11311
11312 static tree
11313 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11314 {
11315   if (!validate_arg (dst, POINTER_TYPE)
11316       || !validate_arg (src, POINTER_TYPE))
11317     return NULL_TREE;
11318   else
11319     {
11320       const char *p = c_getstr (src);
11321
11322       /* If the string length is zero, return the dst parameter.  */
11323       if (p && *p == '\0')
11324         return dst;
11325
11326       if (optimize_insn_for_speed_p ())
11327         {
11328           /* See if we can store by pieces into (dst + strlen(dst)).  */
11329           tree newdst, call;
11330           tree strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11331           tree strcpy_fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11332
11333           if (!strlen_fn || !strcpy_fn)
11334             return NULL_TREE;
11335
11336           /* If we don't have a movstr we don't want to emit an strcpy
11337              call.  We have to do that if the length of the source string
11338              isn't computable (in that case we can use memcpy probably
11339              later expanding to a sequence of mov instructions).  If we
11340              have movstr instructions we can emit strcpy calls.  */
11341           if (!HAVE_movstr)
11342             {
11343               tree len = c_strlen (src, 1);
11344               if (! len || TREE_SIDE_EFFECTS (len))
11345                 return NULL_TREE;
11346             }
11347
11348           /* Stabilize the argument list.  */
11349           dst = builtin_save_expr (dst);
11350
11351           /* Create strlen (dst).  */
11352           newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11353           /* Create (dst p+ strlen (dst)).  */
11354
11355           newdst = fold_build2_loc (loc, POINTER_PLUS_EXPR,
11356                                 TREE_TYPE (dst), dst, newdst);
11357           newdst = builtin_save_expr (newdst);
11358
11359           call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11360           return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11361         }
11362       return NULL_TREE;
11363     }
11364 }
11365
11366 /* Simplify a call to the strncat builtin.  DST, SRC, and LEN are the
11367    arguments to the call.
11368
11369    Return NULL_TREE if no simplification was possible, otherwise return the
11370    simplified form of the call as a tree.
11371
11372    The simplified form may be a constant or other expression which
11373    computes the same value, but in a more efficient manner (including
11374    calls to other builtin functions).
11375
11376    The call may contain arguments which need to be evaluated, but
11377    which are not useful to determine the result of the call.  In
11378    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11379    COMPOUND_EXPR will be an argument which must be evaluated.
11380    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11381    COMPOUND_EXPR in the chain will contain the tree for the simplified
11382    form of the builtin function call.  */
11383
11384 static tree
11385 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11386 {
11387   if (!validate_arg (dst, POINTER_TYPE)
11388       || !validate_arg (src, POINTER_TYPE)
11389       || !validate_arg (len, INTEGER_TYPE))
11390     return NULL_TREE;
11391   else
11392     {
11393       const char *p = c_getstr (src);
11394
11395       /* If the requested length is zero, or the src parameter string
11396          length is zero, return the dst parameter.  */
11397       if (integer_zerop (len) || (p && *p == '\0'))
11398         return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11399
11400       /* If the requested len is greater than or equal to the string
11401          length, call strcat.  */
11402       if (TREE_CODE (len) == INTEGER_CST && p
11403           && compare_tree_int (len, strlen (p)) >= 0)
11404         {
11405           tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
11406
11407           /* If the replacement _DECL isn't initialized, don't do the
11408              transformation.  */
11409           if (!fn)
11410             return NULL_TREE;
11411
11412           return build_call_expr_loc (loc, fn, 2, dst, src);
11413         }
11414       return NULL_TREE;
11415     }
11416 }
11417
11418 /* Simplify a call to the strspn builtin.  S1 and S2 are the arguments
11419    to the call.
11420
11421    Return NULL_TREE if no simplification was possible, otherwise return the
11422    simplified form of the call as a tree.
11423
11424    The simplified form may be a constant or other expression which
11425    computes the same value, but in a more efficient manner (including
11426    calls to other builtin functions).
11427
11428    The call may contain arguments which need to be evaluated, but
11429    which are not useful to determine the result of the call.  In
11430    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11431    COMPOUND_EXPR will be an argument which must be evaluated.
11432    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11433    COMPOUND_EXPR in the chain will contain the tree for the simplified
11434    form of the builtin function call.  */
11435
11436 static tree
11437 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11438 {
11439   if (!validate_arg (s1, POINTER_TYPE)
11440       || !validate_arg (s2, POINTER_TYPE))
11441     return NULL_TREE;
11442   else
11443     {
11444       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11445
11446       /* If both arguments are constants, evaluate at compile-time.  */
11447       if (p1 && p2)
11448         {
11449           const size_t r = strspn (p1, p2);
11450           return size_int (r);
11451         }
11452
11453       /* If either argument is "", return NULL_TREE.  */
11454       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11455         /* Evaluate and ignore both arguments in case either one has
11456            side-effects.  */
11457         return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11458                                   s1, s2);
11459       return NULL_TREE;
11460     }
11461 }
11462
11463 /* Simplify a call to the strcspn builtin.  S1 and S2 are the arguments
11464    to the call.
11465
11466    Return NULL_TREE if no simplification was possible, otherwise return the
11467    simplified form of the call as a tree.
11468
11469    The simplified form may be a constant or other expression which
11470    computes the same value, but in a more efficient manner (including
11471    calls to other builtin functions).
11472
11473    The call may contain arguments which need to be evaluated, but
11474    which are not useful to determine the result of the call.  In
11475    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11476    COMPOUND_EXPR will be an argument which must be evaluated.
11477    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11478    COMPOUND_EXPR in the chain will contain the tree for the simplified
11479    form of the builtin function call.  */
11480
11481 static tree
11482 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11483 {
11484   if (!validate_arg (s1, POINTER_TYPE)
11485       || !validate_arg (s2, POINTER_TYPE))
11486     return NULL_TREE;
11487   else
11488     {
11489       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11490
11491       /* If both arguments are constants, evaluate at compile-time.  */
11492       if (p1 && p2)
11493         {
11494           const size_t r = strcspn (p1, p2);
11495           return size_int (r);
11496         }
11497
11498       /* If the first argument is "", return NULL_TREE.  */
11499       if (p1 && *p1 == '\0')
11500         {
11501           /* Evaluate and ignore argument s2 in case it has
11502              side-effects.  */
11503           return omit_one_operand_loc (loc, size_type_node,
11504                                    size_zero_node, s2);
11505         }
11506
11507       /* If the second argument is "", return __builtin_strlen(s1).  */
11508       if (p2 && *p2 == '\0')
11509         {
11510           tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11511
11512           /* If the replacement _DECL isn't initialized, don't do the
11513              transformation.  */
11514           if (!fn)
11515             return NULL_TREE;
11516
11517           return build_call_expr_loc (loc, fn, 1, s1);
11518         }
11519       return NULL_TREE;
11520     }
11521 }
11522
11523 /* Fold a call to the fputs builtin.  ARG0 and ARG1 are the arguments
11524    to the call.  IGNORE is true if the value returned
11525    by the builtin will be ignored.  UNLOCKED is true is true if this
11526    actually a call to fputs_unlocked.  If LEN in non-NULL, it represents
11527    the known length of the string.  Return NULL_TREE if no simplification
11528    was possible.  */
11529
11530 tree
11531 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
11532                     bool ignore, bool unlocked, tree len)
11533 {
11534   /* If we're using an unlocked function, assume the other unlocked
11535      functions exist explicitly.  */
11536   tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
11537     : implicit_built_in_decls[BUILT_IN_FPUTC];
11538   tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
11539     : implicit_built_in_decls[BUILT_IN_FWRITE];
11540
11541   /* If the return value is used, don't do the transformation.  */
11542   if (!ignore)
11543     return NULL_TREE;
11544
11545   /* Verify the arguments in the original call.  */
11546   if (!validate_arg (arg0, POINTER_TYPE)
11547       || !validate_arg (arg1, POINTER_TYPE))
11548     return NULL_TREE;
11549
11550   if (! len)
11551     len = c_strlen (arg0, 0);
11552
11553   /* Get the length of the string passed to fputs.  If the length
11554      can't be determined, punt.  */
11555   if (!len
11556       || TREE_CODE (len) != INTEGER_CST)
11557     return NULL_TREE;
11558
11559   switch (compare_tree_int (len, 1))
11560     {
11561     case -1: /* length is 0, delete the call entirely .  */
11562       return omit_one_operand_loc (loc, integer_type_node,
11563                                integer_zero_node, arg1);;
11564
11565     case 0: /* length is 1, call fputc.  */
11566       {
11567         const char *p = c_getstr (arg0);
11568
11569         if (p != NULL)
11570           {
11571             if (fn_fputc)
11572               return build_call_expr_loc (loc, fn_fputc, 2,
11573                                       build_int_cst (NULL_TREE, p[0]), arg1);
11574             else
11575               return NULL_TREE;
11576           }
11577       }
11578       /* FALLTHROUGH */
11579     case 1: /* length is greater than 1, call fwrite.  */
11580       {
11581         /* If optimizing for size keep fputs.  */
11582         if (optimize_function_for_size_p (cfun))
11583           return NULL_TREE;
11584         /* New argument list transforming fputs(string, stream) to
11585            fwrite(string, 1, len, stream).  */
11586         if (fn_fwrite)
11587           return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
11588                                   size_one_node, len, arg1);
11589         else
11590           return NULL_TREE;
11591       }
11592     default:
11593       gcc_unreachable ();
11594     }
11595   return NULL_TREE;
11596 }
11597
11598 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11599    produced.  False otherwise.  This is done so that we don't output the error
11600    or warning twice or three times.  */
11601
11602 bool
11603 fold_builtin_next_arg (tree exp, bool va_start_p)
11604 {
11605   tree fntype = TREE_TYPE (current_function_decl);
11606   int nargs = call_expr_nargs (exp);
11607   tree arg;
11608
11609   if (!stdarg_p (fntype))
11610     {
11611       error ("%<va_start%> used in function with fixed args");
11612       return true;
11613     }
11614
11615   if (va_start_p)
11616     {
11617       if (va_start_p && (nargs != 2))
11618         {
11619           error ("wrong number of arguments to function %<va_start%>");
11620           return true;
11621         }
11622       arg = CALL_EXPR_ARG (exp, 1);
11623     }
11624   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11625      when we checked the arguments and if needed issued a warning.  */
11626   else
11627     {
11628       if (nargs == 0)
11629         {
11630           /* Evidently an out of date version of <stdarg.h>; can't validate
11631              va_start's second argument, but can still work as intended.  */
11632           warning (0, "%<__builtin_next_arg%> called without an argument");
11633           return true;
11634         }
11635       else if (nargs > 1)
11636         {
11637           error ("wrong number of arguments to function %<__builtin_next_arg%>");
11638           return true;
11639         }
11640       arg = CALL_EXPR_ARG (exp, 0);
11641     }
11642
11643   if (TREE_CODE (arg) == SSA_NAME)
11644     arg = SSA_NAME_VAR (arg);
11645
11646   /* We destructively modify the call to be __builtin_va_start (ap, 0)
11647      or __builtin_next_arg (0) the first time we see it, after checking
11648      the arguments and if needed issuing a warning.  */
11649   if (!integer_zerop (arg))
11650     {
11651       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
11652
11653       /* Strip off all nops for the sake of the comparison.  This
11654          is not quite the same as STRIP_NOPS.  It does more.
11655          We must also strip off INDIRECT_EXPR for C++ reference
11656          parameters.  */
11657       while (CONVERT_EXPR_P (arg)
11658              || TREE_CODE (arg) == INDIRECT_REF)
11659         arg = TREE_OPERAND (arg, 0);
11660       if (arg != last_parm)
11661         {
11662           /* FIXME: Sometimes with the tree optimizers we can get the
11663              not the last argument even though the user used the last
11664              argument.  We just warn and set the arg to be the last
11665              argument so that we will get wrong-code because of
11666              it.  */
11667           warning (0, "second parameter of %<va_start%> not last named argument");
11668         }
11669
11670       /* Undefined by C99 7.15.1.4p4 (va_start):
11671          "If the parameter parmN is declared with the register storage
11672          class, with a function or array type, or with a type that is
11673          not compatible with the type that results after application of
11674          the default argument promotions, the behavior is undefined."
11675       */
11676       else if (DECL_REGISTER (arg))
11677         warning (0, "undefined behaviour when second parameter of "
11678                  "%<va_start%> is declared with %<register%> storage");
11679
11680       /* We want to verify the second parameter just once before the tree
11681          optimizers are run and then avoid keeping it in the tree,
11682          as otherwise we could warn even for correct code like:
11683          void foo (int i, ...)
11684          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
11685       if (va_start_p)
11686         CALL_EXPR_ARG (exp, 1) = integer_zero_node;
11687       else
11688         CALL_EXPR_ARG (exp, 0) = integer_zero_node;
11689     }
11690   return false;
11691 }
11692
11693
11694 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11695    ORIG may be null if this is a 2-argument call.  We don't attempt to
11696    simplify calls with more than 3 arguments.
11697
11698    Return NULL_TREE if no simplification was possible, otherwise return the
11699    simplified form of the call as a tree.  If IGNORED is true, it means that
11700    the caller does not use the returned value of the function.  */
11701
11702 static tree
11703 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
11704                       tree orig, int ignored)
11705 {
11706   tree call, retval;
11707   const char *fmt_str = NULL;
11708
11709   /* Verify the required arguments in the original call.  We deal with two
11710      types of sprintf() calls: 'sprintf (str, fmt)' and
11711      'sprintf (dest, "%s", orig)'.  */
11712   if (!validate_arg (dest, POINTER_TYPE)
11713       || !validate_arg (fmt, POINTER_TYPE))
11714     return NULL_TREE;
11715   if (orig && !validate_arg (orig, POINTER_TYPE))
11716     return NULL_TREE;
11717
11718   /* Check whether the format is a literal string constant.  */
11719   fmt_str = c_getstr (fmt);
11720   if (fmt_str == NULL)
11721     return NULL_TREE;
11722
11723   call = NULL_TREE;
11724   retval = NULL_TREE;
11725
11726   if (!init_target_chars ())
11727     return NULL_TREE;
11728
11729   /* If the format doesn't contain % args or %%, use strcpy.  */
11730   if (strchr (fmt_str, target_percent) == NULL)
11731     {
11732       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11733
11734       if (!fn)
11735         return NULL_TREE;
11736
11737       /* Don't optimize sprintf (buf, "abc", ptr++).  */
11738       if (orig)
11739         return NULL_TREE;
11740
11741       /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11742          'format' is known to contain no % formats.  */
11743       call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11744       if (!ignored)
11745         retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11746     }
11747
11748   /* If the format is "%s", use strcpy if the result isn't used.  */
11749   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11750     {
11751       tree fn;
11752       fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11753
11754       if (!fn)
11755         return NULL_TREE;
11756
11757       /* Don't crash on sprintf (str1, "%s").  */
11758       if (!orig)
11759         return NULL_TREE;
11760
11761       /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2).  */
11762       if (!ignored)
11763         {
11764           retval = c_strlen (orig, 1);
11765           if (!retval || TREE_CODE (retval) != INTEGER_CST)
11766             return NULL_TREE;
11767         }
11768       call = build_call_expr_loc (loc, fn, 2, dest, orig);
11769     }
11770
11771   if (call && retval)
11772     {
11773       retval = fold_convert_loc
11774         (loc, TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
11775          retval);
11776       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11777     }
11778   else
11779     return call;
11780 }
11781
11782 /* Expand a call EXP to __builtin_object_size.  */
11783
11784 rtx
11785 expand_builtin_object_size (tree exp)
11786 {
11787   tree ost;
11788   int object_size_type;
11789   tree fndecl = get_callee_fndecl (exp);
11790
11791   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
11792     {
11793       error ("%Kfirst argument of %D must be a pointer, second integer constant",
11794              exp, fndecl);
11795       expand_builtin_trap ();
11796       return const0_rtx;
11797     }
11798
11799   ost = CALL_EXPR_ARG (exp, 1);
11800   STRIP_NOPS (ost);
11801
11802   if (TREE_CODE (ost) != INTEGER_CST
11803       || tree_int_cst_sgn (ost) < 0
11804       || compare_tree_int (ost, 3) > 0)
11805     {
11806       error ("%Klast argument of %D is not integer constant between 0 and 3",
11807              exp, fndecl);
11808       expand_builtin_trap ();
11809       return const0_rtx;
11810     }
11811
11812   object_size_type = tree_low_cst (ost, 0);
11813
11814   return object_size_type < 2 ? constm1_rtx : const0_rtx;
11815 }
11816
11817 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11818    FCODE is the BUILT_IN_* to use.
11819    Return NULL_RTX if we failed; the caller should emit a normal call,
11820    otherwise try to get the result in TARGET, if convenient (and in
11821    mode MODE if that's convenient).  */
11822
11823 static rtx
11824 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
11825                            enum built_in_function fcode)
11826 {
11827   tree dest, src, len, size;
11828
11829   if (!validate_arglist (exp,
11830                          POINTER_TYPE,
11831                          fcode == BUILT_IN_MEMSET_CHK
11832                          ? INTEGER_TYPE : POINTER_TYPE,
11833                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
11834     return NULL_RTX;
11835
11836   dest = CALL_EXPR_ARG (exp, 0);
11837   src = CALL_EXPR_ARG (exp, 1);
11838   len = CALL_EXPR_ARG (exp, 2);
11839   size = CALL_EXPR_ARG (exp, 3);
11840
11841   if (! host_integerp (size, 1))
11842     return NULL_RTX;
11843
11844   if (host_integerp (len, 1) || integer_all_onesp (size))
11845     {
11846       tree fn;
11847
11848       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
11849         {
11850           warning_at (tree_nonartificial_location (exp),
11851                       0, "%Kcall to %D will always overflow destination buffer",
11852                       exp, get_callee_fndecl (exp));
11853           return NULL_RTX;
11854         }
11855
11856       fn = NULL_TREE;
11857       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11858          mem{cpy,pcpy,move,set} is available.  */
11859       switch (fcode)
11860         {
11861         case BUILT_IN_MEMCPY_CHK:
11862           fn = built_in_decls[BUILT_IN_MEMCPY];
11863           break;
11864         case BUILT_IN_MEMPCPY_CHK:
11865           fn = built_in_decls[BUILT_IN_MEMPCPY];
11866           break;
11867         case BUILT_IN_MEMMOVE_CHK:
11868           fn = built_in_decls[BUILT_IN_MEMMOVE];
11869           break;
11870         case BUILT_IN_MEMSET_CHK:
11871           fn = built_in_decls[BUILT_IN_MEMSET];
11872           break;
11873         default:
11874           break;
11875         }
11876
11877       if (! fn)
11878         return NULL_RTX;
11879
11880       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
11881       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
11882       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11883       return expand_expr (fn, target, mode, EXPAND_NORMAL);
11884     }
11885   else if (fcode == BUILT_IN_MEMSET_CHK)
11886     return NULL_RTX;
11887   else
11888     {
11889       unsigned int dest_align
11890         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
11891
11892       /* If DEST is not a pointer type, call the normal function.  */
11893       if (dest_align == 0)
11894         return NULL_RTX;
11895
11896       /* If SRC and DEST are the same (and not volatile), do nothing.  */
11897       if (operand_equal_p (src, dest, 0))
11898         {
11899           tree expr;
11900
11901           if (fcode != BUILT_IN_MEMPCPY_CHK)
11902             {
11903               /* Evaluate and ignore LEN in case it has side-effects.  */
11904               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
11905               return expand_expr (dest, target, mode, EXPAND_NORMAL);
11906             }
11907
11908           expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
11909           return expand_expr (expr, target, mode, EXPAND_NORMAL);
11910         }
11911
11912       /* __memmove_chk special case.  */
11913       if (fcode == BUILT_IN_MEMMOVE_CHK)
11914         {
11915           unsigned int src_align
11916             = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
11917
11918           if (src_align == 0)
11919             return NULL_RTX;
11920
11921           /* If src is categorized for a readonly section we can use
11922              normal __memcpy_chk.  */
11923           if (readonly_data_expr (src))
11924             {
11925               tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
11926               if (!fn)
11927                 return NULL_RTX;
11928               fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
11929                                           dest, src, len, size);
11930               gcc_assert (TREE_CODE (fn) == CALL_EXPR);
11931               CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11932               return expand_expr (fn, target, mode, EXPAND_NORMAL);
11933             }
11934         }
11935       return NULL_RTX;
11936     }
11937 }
11938
11939 /* Emit warning if a buffer overflow is detected at compile time.  */
11940
11941 static void
11942 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
11943 {
11944   int is_strlen = 0;
11945   tree len, size;
11946   location_t loc = tree_nonartificial_location (exp);
11947
11948   switch (fcode)
11949     {
11950     case BUILT_IN_STRCPY_CHK:
11951     case BUILT_IN_STPCPY_CHK:
11952     /* For __strcat_chk the warning will be emitted only if overflowing
11953        by at least strlen (dest) + 1 bytes.  */
11954     case BUILT_IN_STRCAT_CHK:
11955       len = CALL_EXPR_ARG (exp, 1);
11956       size = CALL_EXPR_ARG (exp, 2);
11957       is_strlen = 1;
11958       break;
11959     case BUILT_IN_STRNCAT_CHK:
11960     case BUILT_IN_STRNCPY_CHK:
11961       len = CALL_EXPR_ARG (exp, 2);
11962       size = CALL_EXPR_ARG (exp, 3);
11963       break;
11964     case BUILT_IN_SNPRINTF_CHK:
11965     case BUILT_IN_VSNPRINTF_CHK:
11966       len = CALL_EXPR_ARG (exp, 1);
11967       size = CALL_EXPR_ARG (exp, 3);
11968       break;
11969     default:
11970       gcc_unreachable ();
11971     }
11972
11973   if (!len || !size)
11974     return;
11975
11976   if (! host_integerp (size, 1) || integer_all_onesp (size))
11977     return;
11978
11979   if (is_strlen)
11980     {
11981       len = c_strlen (len, 1);
11982       if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
11983         return;
11984     }
11985   else if (fcode == BUILT_IN_STRNCAT_CHK)
11986     {
11987       tree src = CALL_EXPR_ARG (exp, 1);
11988       if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
11989         return;
11990       src = c_strlen (src, 1);
11991       if (! src || ! host_integerp (src, 1))
11992         {
11993           warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
11994                       exp, get_callee_fndecl (exp));
11995           return;
11996         }
11997       else if (tree_int_cst_lt (src, size))
11998         return;
11999     }
12000   else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12001     return;
12002
12003   warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12004               exp, get_callee_fndecl (exp));
12005 }
12006
12007 /* Emit warning if a buffer overflow is detected at compile time
12008    in __sprintf_chk/__vsprintf_chk calls.  */
12009
12010 static void
12011 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12012 {
12013   tree size, len, fmt;
12014   const char *fmt_str;
12015   int nargs = call_expr_nargs (exp);
12016
12017   /* Verify the required arguments in the original call.  */
12018
12019   if (nargs < 4)
12020     return;
12021   size = CALL_EXPR_ARG (exp, 2);
12022   fmt = CALL_EXPR_ARG (exp, 3);
12023
12024   if (! host_integerp (size, 1) || integer_all_onesp (size))
12025     return;
12026
12027   /* Check whether the format is a literal string constant.  */
12028   fmt_str = c_getstr (fmt);
12029   if (fmt_str == NULL)
12030     return;
12031
12032   if (!init_target_chars ())
12033     return;
12034
12035   /* If the format doesn't contain % args or %%, we know its size.  */
12036   if (strchr (fmt_str, target_percent) == 0)
12037     len = build_int_cstu (size_type_node, strlen (fmt_str));
12038   /* If the format is "%s" and first ... argument is a string literal,
12039      we know it too.  */
12040   else if (fcode == BUILT_IN_SPRINTF_CHK
12041            && strcmp (fmt_str, target_percent_s) == 0)
12042     {
12043       tree arg;
12044
12045       if (nargs < 5)
12046         return;
12047       arg = CALL_EXPR_ARG (exp, 4);
12048       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12049         return;
12050
12051       len = c_strlen (arg, 1);
12052       if (!len || ! host_integerp (len, 1))
12053         return;
12054     }
12055   else
12056     return;
12057
12058   if (! tree_int_cst_lt (len, size))
12059     warning_at (tree_nonartificial_location (exp),
12060                 0, "%Kcall to %D will always overflow destination buffer",
12061                 exp, get_callee_fndecl (exp));
12062 }
12063
12064 /* Emit warning if a free is called with address of a variable.  */
12065
12066 static void
12067 maybe_emit_free_warning (tree exp)
12068 {
12069   tree arg = CALL_EXPR_ARG (exp, 0);
12070
12071   STRIP_NOPS (arg);
12072   if (TREE_CODE (arg) != ADDR_EXPR)
12073     return;
12074
12075   arg = get_base_address (TREE_OPERAND (arg, 0));
12076   if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
12077     return;
12078
12079   if (SSA_VAR_P (arg))
12080     warning_at (tree_nonartificial_location (exp),
12081                 0, "%Kattempt to free a non-heap object %qD", exp, arg);
12082   else
12083     warning_at (tree_nonartificial_location (exp),
12084                 0, "%Kattempt to free a non-heap object", exp);
12085 }
12086
12087 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12088    if possible.  */
12089
12090 tree
12091 fold_builtin_object_size (tree ptr, tree ost)
12092 {
12093   unsigned HOST_WIDE_INT bytes;
12094   int object_size_type;
12095
12096   if (!validate_arg (ptr, POINTER_TYPE)
12097       || !validate_arg (ost, INTEGER_TYPE))
12098     return NULL_TREE;
12099
12100   STRIP_NOPS (ost);
12101
12102   if (TREE_CODE (ost) != INTEGER_CST
12103       || tree_int_cst_sgn (ost) < 0
12104       || compare_tree_int (ost, 3) > 0)
12105     return NULL_TREE;
12106
12107   object_size_type = tree_low_cst (ost, 0);
12108
12109   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12110      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12111      and (size_t) 0 for types 2 and 3.  */
12112   if (TREE_SIDE_EFFECTS (ptr))
12113     return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12114
12115   if (TREE_CODE (ptr) == ADDR_EXPR)
12116     {
12117       bytes = compute_builtin_object_size (ptr, object_size_type);
12118       if (double_int_fits_to_tree_p (size_type_node,
12119                                      uhwi_to_double_int (bytes)))
12120         return build_int_cstu (size_type_node, bytes);
12121     }
12122   else if (TREE_CODE (ptr) == SSA_NAME)
12123     {
12124       /* If object size is not known yet, delay folding until
12125        later.  Maybe subsequent passes will help determining
12126        it.  */
12127       bytes = compute_builtin_object_size (ptr, object_size_type);
12128       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
12129           && double_int_fits_to_tree_p (size_type_node,
12130                                         uhwi_to_double_int (bytes)))
12131         return build_int_cstu (size_type_node, bytes);
12132     }
12133
12134   return NULL_TREE;
12135 }
12136
12137 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12138    DEST, SRC, LEN, and SIZE are the arguments to the call.
12139    IGNORE is true, if return value can be ignored.  FCODE is the BUILT_IN_*
12140    code of the builtin.  If MAXLEN is not NULL, it is maximum length
12141    passed as third argument.  */
12142
12143 tree
12144 fold_builtin_memory_chk (location_t loc, tree fndecl,
12145                          tree dest, tree src, tree len, tree size,
12146                          tree maxlen, bool ignore,
12147                          enum built_in_function fcode)
12148 {
12149   tree fn;
12150
12151   if (!validate_arg (dest, POINTER_TYPE)
12152       || !validate_arg (src,
12153                         (fcode == BUILT_IN_MEMSET_CHK
12154                          ? INTEGER_TYPE : POINTER_TYPE))
12155       || !validate_arg (len, INTEGER_TYPE)
12156       || !validate_arg (size, INTEGER_TYPE))
12157     return NULL_TREE;
12158
12159   /* If SRC and DEST are the same (and not volatile), return DEST
12160      (resp. DEST+LEN for __mempcpy_chk).  */
12161   if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12162     {
12163       if (fcode != BUILT_IN_MEMPCPY_CHK)
12164         return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12165                                  dest, len);
12166       else
12167         {
12168           tree temp = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest),
12169                                    dest, len);
12170           return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12171         }
12172     }
12173
12174   if (! host_integerp (size, 1))
12175     return NULL_TREE;
12176
12177   if (! integer_all_onesp (size))
12178     {
12179       if (! host_integerp (len, 1))
12180         {
12181           /* If LEN is not constant, try MAXLEN too.
12182              For MAXLEN only allow optimizing into non-_ocs function
12183              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12184           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12185             {
12186               if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12187                 {
12188                   /* (void) __mempcpy_chk () can be optimized into
12189                      (void) __memcpy_chk ().  */
12190                   fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12191                   if (!fn)
12192                     return NULL_TREE;
12193
12194                   return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12195                 }
12196               return NULL_TREE;
12197             }
12198         }
12199       else
12200         maxlen = len;
12201
12202       if (tree_int_cst_lt (size, maxlen))
12203         return NULL_TREE;
12204     }
12205
12206   fn = NULL_TREE;
12207   /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12208      mem{cpy,pcpy,move,set} is available.  */
12209   switch (fcode)
12210     {
12211     case BUILT_IN_MEMCPY_CHK:
12212       fn = built_in_decls[BUILT_IN_MEMCPY];
12213       break;
12214     case BUILT_IN_MEMPCPY_CHK:
12215       fn = built_in_decls[BUILT_IN_MEMPCPY];
12216       break;
12217     case BUILT_IN_MEMMOVE_CHK:
12218       fn = built_in_decls[BUILT_IN_MEMMOVE];
12219       break;
12220     case BUILT_IN_MEMSET_CHK:
12221       fn = built_in_decls[BUILT_IN_MEMSET];
12222       break;
12223     default:
12224       break;
12225     }
12226
12227   if (!fn)
12228     return NULL_TREE;
12229
12230   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12231 }
12232
12233 /* Fold a call to the __st[rp]cpy_chk builtin.
12234    DEST, SRC, and SIZE are the arguments to the call.
12235    IGNORE is true if return value can be ignored.  FCODE is the BUILT_IN_*
12236    code of the builtin.  If MAXLEN is not NULL, it is maximum length of
12237    strings passed as second argument.  */
12238
12239 tree
12240 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12241                          tree src, tree size,
12242                          tree maxlen, bool ignore,
12243                          enum built_in_function fcode)
12244 {
12245   tree len, fn;
12246
12247   if (!validate_arg (dest, POINTER_TYPE)
12248       || !validate_arg (src, POINTER_TYPE)
12249       || !validate_arg (size, INTEGER_TYPE))
12250     return NULL_TREE;
12251
12252   /* If SRC and DEST are the same (and not volatile), return DEST.  */
12253   if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12254     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12255
12256   if (! host_integerp (size, 1))
12257     return NULL_TREE;
12258
12259   if (! integer_all_onesp (size))
12260     {
12261       len = c_strlen (src, 1);
12262       if (! len || ! host_integerp (len, 1))
12263         {
12264           /* If LEN is not constant, try MAXLEN too.
12265              For MAXLEN only allow optimizing into non-_ocs function
12266              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12267           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12268             {
12269               if (fcode == BUILT_IN_STPCPY_CHK)
12270                 {
12271                   if (! ignore)
12272                     return NULL_TREE;
12273
12274                   /* If return value of __stpcpy_chk is ignored,
12275                      optimize into __strcpy_chk.  */
12276                   fn = built_in_decls[BUILT_IN_STRCPY_CHK];
12277                   if (!fn)
12278                     return NULL_TREE;
12279
12280                   return build_call_expr_loc (loc, fn, 3, dest, src, size);
12281                 }
12282
12283               if (! len || TREE_SIDE_EFFECTS (len))
12284                 return NULL_TREE;
12285
12286               /* If c_strlen returned something, but not a constant,
12287                  transform __strcpy_chk into __memcpy_chk.  */
12288               fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12289               if (!fn)
12290                 return NULL_TREE;
12291
12292               len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
12293               return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12294                                        build_call_expr_loc (loc, fn, 4,
12295                                                         dest, src, len, size));
12296             }
12297         }
12298       else
12299         maxlen = len;
12300
12301       if (! tree_int_cst_lt (maxlen, size))
12302         return NULL_TREE;
12303     }
12304
12305   /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available.  */
12306   fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
12307                       ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
12308   if (!fn)
12309     return NULL_TREE;
12310
12311   return build_call_expr_loc (loc, fn, 2, dest, src);
12312 }
12313
12314 /* Fold a call to the __strncpy_chk builtin.  DEST, SRC, LEN, and SIZE
12315    are the arguments to the call.  If MAXLEN is not NULL, it is maximum
12316    length passed as third argument.  */
12317
12318 tree
12319 fold_builtin_strncpy_chk (location_t loc, tree dest, tree src,
12320                           tree len, tree size, tree maxlen)
12321 {
12322   tree fn;
12323
12324   if (!validate_arg (dest, POINTER_TYPE)
12325       || !validate_arg (src, POINTER_TYPE)
12326       || !validate_arg (len, INTEGER_TYPE)
12327       || !validate_arg (size, INTEGER_TYPE))
12328     return NULL_TREE;
12329
12330   if (! host_integerp (size, 1))
12331     return NULL_TREE;
12332
12333   if (! integer_all_onesp (size))
12334     {
12335       if (! host_integerp (len, 1))
12336         {
12337           /* If LEN is not constant, try MAXLEN too.
12338              For MAXLEN only allow optimizing into non-_ocs function
12339              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12340           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12341             return NULL_TREE;
12342         }
12343       else
12344         maxlen = len;
12345
12346       if (tree_int_cst_lt (size, maxlen))
12347         return NULL_TREE;
12348     }
12349
12350   /* If __builtin_strncpy_chk is used, assume strncpy is available.  */
12351   fn = built_in_decls[BUILT_IN_STRNCPY];
12352   if (!fn)
12353     return NULL_TREE;
12354
12355   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12356 }
12357
12358 /* Fold a call to the __strcat_chk builtin FNDECL.  DEST, SRC, and SIZE
12359    are the arguments to the call.  */
12360
12361 static tree
12362 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12363                          tree src, tree size)
12364 {
12365   tree fn;
12366   const char *p;
12367
12368   if (!validate_arg (dest, POINTER_TYPE)
12369       || !validate_arg (src, POINTER_TYPE)
12370       || !validate_arg (size, INTEGER_TYPE))
12371     return NULL_TREE;
12372
12373   p = c_getstr (src);
12374   /* If the SRC parameter is "", return DEST.  */
12375   if (p && *p == '\0')
12376     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12377
12378   if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12379     return NULL_TREE;
12380
12381   /* If __builtin_strcat_chk is used, assume strcat is available.  */
12382   fn = built_in_decls[BUILT_IN_STRCAT];
12383   if (!fn)
12384     return NULL_TREE;
12385
12386   return build_call_expr_loc (loc, fn, 2, dest, src);
12387 }
12388
12389 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12390    LEN, and SIZE.  */
12391
12392 static tree
12393 fold_builtin_strncat_chk (location_t loc, tree fndecl,
12394                           tree dest, tree src, tree len, tree size)
12395 {
12396   tree fn;
12397   const char *p;
12398
12399   if (!validate_arg (dest, POINTER_TYPE)
12400       || !validate_arg (src, POINTER_TYPE)
12401       || !validate_arg (size, INTEGER_TYPE)
12402       || !validate_arg (size, INTEGER_TYPE))
12403     return NULL_TREE;
12404
12405   p = c_getstr (src);
12406   /* If the SRC parameter is "" or if LEN is 0, return DEST.  */
12407   if (p && *p == '\0')
12408     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12409   else if (integer_zerop (len))
12410     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12411
12412   if (! host_integerp (size, 1))
12413     return NULL_TREE;
12414
12415   if (! integer_all_onesp (size))
12416     {
12417       tree src_len = c_strlen (src, 1);
12418       if (src_len
12419           && host_integerp (src_len, 1)
12420           && host_integerp (len, 1)
12421           && ! tree_int_cst_lt (len, src_len))
12422         {
12423           /* If LEN >= strlen (SRC), optimize into __strcat_chk.  */
12424           fn = built_in_decls[BUILT_IN_STRCAT_CHK];
12425           if (!fn)
12426             return NULL_TREE;
12427
12428           return build_call_expr_loc (loc, fn, 3, dest, src, size);
12429         }
12430       return NULL_TREE;
12431     }
12432
12433   /* If __builtin_strncat_chk is used, assume strncat is available.  */
12434   fn = built_in_decls[BUILT_IN_STRNCAT];
12435   if (!fn)
12436     return NULL_TREE;
12437
12438   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12439 }
12440
12441 /* Fold a call EXP to __{,v}sprintf_chk.  Return NULL_TREE if
12442    a normal call should be emitted rather than expanding the function
12443    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
12444
12445 static tree
12446 fold_builtin_sprintf_chk (location_t loc, tree exp,
12447                           enum built_in_function fcode)
12448 {
12449   tree dest, size, len, fn, fmt, flag;
12450   const char *fmt_str;
12451   int nargs = call_expr_nargs (exp);
12452
12453   /* Verify the required arguments in the original call.  */
12454   if (nargs < 4)
12455     return NULL_TREE;
12456   dest = CALL_EXPR_ARG (exp, 0);
12457   if (!validate_arg (dest, POINTER_TYPE))
12458     return NULL_TREE;
12459   flag = CALL_EXPR_ARG (exp, 1);
12460   if (!validate_arg (flag, INTEGER_TYPE))
12461     return NULL_TREE;
12462   size = CALL_EXPR_ARG (exp, 2);
12463   if (!validate_arg (size, INTEGER_TYPE))
12464     return NULL_TREE;
12465   fmt = CALL_EXPR_ARG (exp, 3);
12466   if (!validate_arg (fmt, POINTER_TYPE))
12467     return NULL_TREE;
12468
12469   if (! host_integerp (size, 1))
12470     return NULL_TREE;
12471
12472   len = NULL_TREE;
12473
12474   if (!init_target_chars ())
12475     return NULL_TREE;
12476
12477   /* Check whether the format is a literal string constant.  */
12478   fmt_str = c_getstr (fmt);
12479   if (fmt_str != NULL)
12480     {
12481       /* If the format doesn't contain % args or %%, we know the size.  */
12482       if (strchr (fmt_str, target_percent) == 0)
12483         {
12484           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
12485             len = build_int_cstu (size_type_node, strlen (fmt_str));
12486         }
12487       /* If the format is "%s" and first ... argument is a string literal,
12488          we know the size too.  */
12489       else if (fcode == BUILT_IN_SPRINTF_CHK
12490                && strcmp (fmt_str, target_percent_s) == 0)
12491         {
12492           tree arg;
12493
12494           if (nargs == 5)
12495             {
12496               arg = CALL_EXPR_ARG (exp, 4);
12497               if (validate_arg (arg, POINTER_TYPE))
12498                 {
12499                   len = c_strlen (arg, 1);
12500                   if (! len || ! host_integerp (len, 1))
12501                     len = NULL_TREE;
12502                 }
12503             }
12504         }
12505     }
12506
12507   if (! integer_all_onesp (size))
12508     {
12509       if (! len || ! tree_int_cst_lt (len, size))
12510         return NULL_TREE;
12511     }
12512
12513   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12514      or if format doesn't contain % chars or is "%s".  */
12515   if (! integer_zerop (flag))
12516     {
12517       if (fmt_str == NULL)
12518         return NULL_TREE;
12519       if (strchr (fmt_str, target_percent) != NULL
12520           && strcmp (fmt_str, target_percent_s))
12521         return NULL_TREE;
12522     }
12523
12524   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
12525   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
12526                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
12527   if (!fn)
12528     return NULL_TREE;
12529
12530   return rewrite_call_expr (loc, exp, 4, fn, 2, dest, fmt);
12531 }
12532
12533 /* Fold a call EXP to {,v}snprintf.  Return NULL_TREE if
12534    a normal call should be emitted rather than expanding the function
12535    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
12536    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
12537    passed as second argument.  */
12538
12539 tree
12540 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
12541                            enum built_in_function fcode)
12542 {
12543   tree dest, size, len, fn, fmt, flag;
12544   const char *fmt_str;
12545
12546   /* Verify the required arguments in the original call.  */
12547   if (call_expr_nargs (exp) < 5)
12548     return NULL_TREE;
12549   dest = CALL_EXPR_ARG (exp, 0);
12550   if (!validate_arg (dest, POINTER_TYPE))
12551     return NULL_TREE;
12552   len = CALL_EXPR_ARG (exp, 1);
12553   if (!validate_arg (len, INTEGER_TYPE))
12554     return NULL_TREE;
12555   flag = CALL_EXPR_ARG (exp, 2);
12556   if (!validate_arg (flag, INTEGER_TYPE))
12557     return NULL_TREE;
12558   size = CALL_EXPR_ARG (exp, 3);
12559   if (!validate_arg (size, INTEGER_TYPE))
12560     return NULL_TREE;
12561   fmt = CALL_EXPR_ARG (exp, 4);
12562   if (!validate_arg (fmt, POINTER_TYPE))
12563     return NULL_TREE;
12564
12565   if (! host_integerp (size, 1))
12566     return NULL_TREE;
12567
12568   if (! integer_all_onesp (size))
12569     {
12570       if (! host_integerp (len, 1))
12571         {
12572           /* If LEN is not constant, try MAXLEN too.
12573              For MAXLEN only allow optimizing into non-_ocs function
12574              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12575           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12576             return NULL_TREE;
12577         }
12578       else
12579         maxlen = len;
12580
12581       if (tree_int_cst_lt (size, maxlen))
12582         return NULL_TREE;
12583     }
12584
12585   if (!init_target_chars ())
12586     return NULL_TREE;
12587
12588   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12589      or if format doesn't contain % chars or is "%s".  */
12590   if (! integer_zerop (flag))
12591     {
12592       fmt_str = c_getstr (fmt);
12593       if (fmt_str == NULL)
12594         return NULL_TREE;
12595       if (strchr (fmt_str, target_percent) != NULL
12596           && strcmp (fmt_str, target_percent_s))
12597         return NULL_TREE;
12598     }
12599
12600   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12601      available.  */
12602   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
12603                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
12604   if (!fn)
12605     return NULL_TREE;
12606
12607   return rewrite_call_expr (loc, exp, 5, fn, 3, dest, len, fmt);
12608 }
12609
12610 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12611    FMT and ARG are the arguments to the call; we don't fold cases with
12612    more than 2 arguments, and ARG may be null if this is a 1-argument case.
12613
12614    Return NULL_TREE if no simplification was possible, otherwise return the
12615    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12616    code of the function to be simplified.  */
12617
12618 static tree
12619 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
12620                      tree arg, bool ignore,
12621                      enum built_in_function fcode)
12622 {
12623   tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
12624   const char *fmt_str = NULL;
12625
12626   /* If the return value is used, don't do the transformation.  */
12627   if (! ignore)
12628     return NULL_TREE;
12629
12630   /* Verify the required arguments in the original call.  */
12631   if (!validate_arg (fmt, POINTER_TYPE))
12632     return NULL_TREE;
12633
12634   /* Check whether the format is a literal string constant.  */
12635   fmt_str = c_getstr (fmt);
12636   if (fmt_str == NULL)
12637     return NULL_TREE;
12638
12639   if (fcode == BUILT_IN_PRINTF_UNLOCKED)
12640     {
12641       /* If we're using an unlocked function, assume the other
12642          unlocked functions exist explicitly.  */
12643       fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
12644       fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
12645     }
12646   else
12647     {
12648       fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
12649       fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
12650     }
12651
12652   if (!init_target_chars ())
12653     return NULL_TREE;
12654
12655   if (strcmp (fmt_str, target_percent_s) == 0
12656       || strchr (fmt_str, target_percent) == NULL)
12657     {
12658       const char *str;
12659
12660       if (strcmp (fmt_str, target_percent_s) == 0)
12661         {
12662           if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12663             return NULL_TREE;
12664
12665           if (!arg || !validate_arg (arg, POINTER_TYPE))
12666             return NULL_TREE;
12667
12668           str = c_getstr (arg);
12669           if (str == NULL)
12670             return NULL_TREE;
12671         }
12672       else
12673         {
12674           /* The format specifier doesn't contain any '%' characters.  */
12675           if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
12676               && arg)
12677             return NULL_TREE;
12678           str = fmt_str;
12679         }
12680
12681       /* If the string was "", printf does nothing.  */
12682       if (str[0] == '\0')
12683         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12684
12685       /* If the string has length of 1, call putchar.  */
12686       if (str[1] == '\0')
12687         {
12688           /* Given printf("c"), (where c is any one character,)
12689              convert "c"[0] to an int and pass that to the replacement
12690              function.  */
12691           newarg = build_int_cst (NULL_TREE, str[0]);
12692           if (fn_putchar)
12693             call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
12694         }
12695       else
12696         {
12697           /* If the string was "string\n", call puts("string").  */
12698           size_t len = strlen (str);
12699           if ((unsigned char)str[len - 1] == target_newline)
12700             {
12701               /* Create a NUL-terminated string that's one char shorter
12702                  than the original, stripping off the trailing '\n'.  */
12703               char *newstr = XALLOCAVEC (char, len);
12704               memcpy (newstr, str, len - 1);
12705               newstr[len - 1] = 0;
12706
12707               newarg = build_string_literal (len, newstr);
12708               if (fn_puts)
12709                 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
12710             }
12711           else
12712             /* We'd like to arrange to call fputs(string,stdout) here,
12713                but we need stdout and don't have a way to get it yet.  */
12714             return NULL_TREE;
12715         }
12716     }
12717
12718   /* The other optimizations can be done only on the non-va_list variants.  */
12719   else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12720     return NULL_TREE;
12721
12722   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
12723   else if (strcmp (fmt_str, target_percent_s_newline) == 0)
12724     {
12725       if (!arg || !validate_arg (arg, POINTER_TYPE))
12726         return NULL_TREE;
12727       if (fn_puts)
12728         call = build_call_expr_loc (loc, fn_puts, 1, arg);
12729     }
12730
12731   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
12732   else if (strcmp (fmt_str, target_percent_c) == 0)
12733     {
12734       if (!arg || !validate_arg (arg, INTEGER_TYPE))
12735         return NULL_TREE;
12736       if (fn_putchar)
12737         call = build_call_expr_loc (loc, fn_putchar, 1, arg);
12738     }
12739
12740   if (!call)
12741     return NULL_TREE;
12742
12743   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12744 }
12745
12746 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
12747    FP, FMT, and ARG are the arguments to the call.  We don't fold calls with
12748    more than 3 arguments, and ARG may be null in the 2-argument case.
12749
12750    Return NULL_TREE if no simplification was possible, otherwise return the
12751    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12752    code of the function to be simplified.  */
12753
12754 static tree
12755 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
12756                       tree fmt, tree arg, bool ignore,
12757                       enum built_in_function fcode)
12758 {
12759   tree fn_fputc, fn_fputs, call = NULL_TREE;
12760   const char *fmt_str = NULL;
12761
12762   /* If the return value is used, don't do the transformation.  */
12763   if (! ignore)
12764     return NULL_TREE;
12765
12766   /* Verify the required arguments in the original call.  */
12767   if (!validate_arg (fp, POINTER_TYPE))
12768     return NULL_TREE;
12769   if (!validate_arg (fmt, POINTER_TYPE))
12770     return NULL_TREE;
12771
12772   /* Check whether the format is a literal string constant.  */
12773   fmt_str = c_getstr (fmt);
12774   if (fmt_str == NULL)
12775     return NULL_TREE;
12776
12777   if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
12778     {
12779       /* If we're using an unlocked function, assume the other
12780          unlocked functions exist explicitly.  */
12781       fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
12782       fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
12783     }
12784   else
12785     {
12786       fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
12787       fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
12788     }
12789
12790   if (!init_target_chars ())
12791     return NULL_TREE;
12792
12793   /* If the format doesn't contain % args or %%, use strcpy.  */
12794   if (strchr (fmt_str, target_percent) == NULL)
12795     {
12796       if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
12797           && arg)
12798         return NULL_TREE;
12799
12800       /* If the format specifier was "", fprintf does nothing.  */
12801       if (fmt_str[0] == '\0')
12802         {
12803           /* If FP has side-effects, just wait until gimplification is
12804              done.  */
12805           if (TREE_SIDE_EFFECTS (fp))
12806             return NULL_TREE;
12807
12808           return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12809         }
12810
12811       /* When "string" doesn't contain %, replace all cases of
12812          fprintf (fp, string) with fputs (string, fp).  The fputs
12813          builtin will take care of special cases like length == 1.  */
12814       if (fn_fputs)
12815         call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
12816     }
12817
12818   /* The other optimizations can be done only on the non-va_list variants.  */
12819   else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
12820     return NULL_TREE;
12821
12822   /* If the format specifier was "%s", call __builtin_fputs (arg, fp).  */
12823   else if (strcmp (fmt_str, target_percent_s) == 0)
12824     {
12825       if (!arg || !validate_arg (arg, POINTER_TYPE))
12826         return NULL_TREE;
12827       if (fn_fputs)
12828         call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
12829     }
12830
12831   /* If the format specifier was "%c", call __builtin_fputc (arg, fp).  */
12832   else if (strcmp (fmt_str, target_percent_c) == 0)
12833     {
12834       if (!arg || !validate_arg (arg, INTEGER_TYPE))
12835         return NULL_TREE;
12836       if (fn_fputc)
12837         call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
12838     }
12839
12840   if (!call)
12841     return NULL_TREE;
12842   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12843 }
12844
12845 /* Initialize format string characters in the target charset.  */
12846
12847 static bool
12848 init_target_chars (void)
12849 {
12850   static bool init;
12851   if (!init)
12852     {
12853       target_newline = lang_hooks.to_target_charset ('\n');
12854       target_percent = lang_hooks.to_target_charset ('%');
12855       target_c = lang_hooks.to_target_charset ('c');
12856       target_s = lang_hooks.to_target_charset ('s');
12857       if (target_newline == 0 || target_percent == 0 || target_c == 0
12858           || target_s == 0)
12859         return false;
12860
12861       target_percent_c[0] = target_percent;
12862       target_percent_c[1] = target_c;
12863       target_percent_c[2] = '\0';
12864
12865       target_percent_s[0] = target_percent;
12866       target_percent_s[1] = target_s;
12867       target_percent_s[2] = '\0';
12868
12869       target_percent_s_newline[0] = target_percent;
12870       target_percent_s_newline[1] = target_s;
12871       target_percent_s_newline[2] = target_newline;
12872       target_percent_s_newline[3] = '\0';
12873
12874       init = true;
12875     }
12876   return true;
12877 }
12878
12879 /* Helper function for do_mpfr_arg*().  Ensure M is a normal number
12880    and no overflow/underflow occurred.  INEXACT is true if M was not
12881    exactly calculated.  TYPE is the tree type for the result.  This
12882    function assumes that you cleared the MPFR flags and then
12883    calculated M to see if anything subsequently set a flag prior to
12884    entering this function.  Return NULL_TREE if any checks fail.  */
12885
12886 static tree
12887 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
12888 {
12889   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12890      overflow/underflow occurred.  If -frounding-math, proceed iff the
12891      result of calling FUNC was exact.  */
12892   if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
12893       && (!flag_rounding_math || !inexact))
12894     {
12895       REAL_VALUE_TYPE rr;
12896
12897       real_from_mpfr (&rr, m, type, GMP_RNDN);
12898       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
12899          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
12900          but the mpft_t is not, then we underflowed in the
12901          conversion.  */
12902       if (real_isfinite (&rr)
12903           && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
12904         {
12905           REAL_VALUE_TYPE rmode;
12906
12907           real_convert (&rmode, TYPE_MODE (type), &rr);
12908           /* Proceed iff the specified mode can hold the value.  */
12909           if (real_identical (&rmode, &rr))
12910             return build_real (type, rmode);
12911         }
12912     }
12913   return NULL_TREE;
12914 }
12915
12916 /* Helper function for do_mpc_arg*().  Ensure M is a normal complex
12917    number and no overflow/underflow occurred.  INEXACT is true if M
12918    was not exactly calculated.  TYPE is the tree type for the result.
12919    This function assumes that you cleared the MPFR flags and then
12920    calculated M to see if anything subsequently set a flag prior to
12921    entering this function.  Return NULL_TREE if any checks fail, if
12922    FORCE_CONVERT is true, then bypass the checks.  */
12923
12924 static tree
12925 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
12926 {
12927   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12928      overflow/underflow occurred.  If -frounding-math, proceed iff the
12929      result of calling FUNC was exact.  */
12930   if (force_convert
12931       || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
12932           && !mpfr_overflow_p () && !mpfr_underflow_p ()
12933           && (!flag_rounding_math || !inexact)))
12934     {
12935       REAL_VALUE_TYPE re, im;
12936
12937       real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
12938       real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
12939       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
12940          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
12941          but the mpft_t is not, then we underflowed in the
12942          conversion.  */
12943       if (force_convert
12944           || (real_isfinite (&re) && real_isfinite (&im)
12945               && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
12946               && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
12947         {
12948           REAL_VALUE_TYPE re_mode, im_mode;
12949
12950           real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
12951           real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
12952           /* Proceed iff the specified mode can hold the value.  */
12953           if (force_convert
12954               || (real_identical (&re_mode, &re)
12955                   && real_identical (&im_mode, &im)))
12956             return build_complex (type, build_real (TREE_TYPE (type), re_mode),
12957                                   build_real (TREE_TYPE (type), im_mode));
12958         }
12959     }
12960   return NULL_TREE;
12961 }
12962
12963 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
12964    FUNC on it and return the resulting value as a tree with type TYPE.
12965    If MIN and/or MAX are not NULL, then the supplied ARG must be
12966    within those bounds.  If INCLUSIVE is true, then MIN/MAX are
12967    acceptable values, otherwise they are not.  The mpfr precision is
12968    set to the precision of TYPE.  We assume that function FUNC returns
12969    zero if the result could be calculated exactly within the requested
12970    precision.  */
12971
12972 static tree
12973 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
12974               const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
12975               bool inclusive)
12976 {
12977   tree result = NULL_TREE;
12978
12979   STRIP_NOPS (arg);
12980
12981   /* To proceed, MPFR must exactly represent the target floating point
12982      format, which only happens when the target base equals two.  */
12983   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
12984       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
12985     {
12986       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
12987
12988       if (real_isfinite (ra)
12989           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
12990           && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
12991         {
12992           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
12993           const int prec = fmt->p;
12994           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
12995           int inexact;
12996           mpfr_t m;
12997
12998           mpfr_init2 (m, prec);
12999           mpfr_from_real (m, ra, GMP_RNDN);
13000           mpfr_clear_flags ();
13001           inexact = func (m, m, rnd);
13002           result = do_mpfr_ckconv (m, type, inexact);
13003           mpfr_clear (m);
13004         }
13005     }
13006
13007   return result;
13008 }
13009
13010 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13011    FUNC on it and return the resulting value as a tree with type TYPE.
13012    The mpfr precision is set to the precision of TYPE.  We assume that
13013    function FUNC returns zero if the result could be calculated
13014    exactly within the requested precision.  */
13015
13016 static tree
13017 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13018               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13019 {
13020   tree result = NULL_TREE;
13021
13022   STRIP_NOPS (arg1);
13023   STRIP_NOPS (arg2);
13024
13025   /* To proceed, MPFR must exactly represent the target floating point
13026      format, which only happens when the target base equals two.  */
13027   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13028       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13029       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13030     {
13031       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13032       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13033
13034       if (real_isfinite (ra1) && real_isfinite (ra2))
13035         {
13036           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13037           const int prec = fmt->p;
13038           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13039           int inexact;
13040           mpfr_t m1, m2;
13041
13042           mpfr_inits2 (prec, m1, m2, NULL);
13043           mpfr_from_real (m1, ra1, GMP_RNDN);
13044           mpfr_from_real (m2, ra2, GMP_RNDN);
13045           mpfr_clear_flags ();
13046           inexact = func (m1, m1, m2, rnd);
13047           result = do_mpfr_ckconv (m1, type, inexact);
13048           mpfr_clears (m1, m2, NULL);
13049         }
13050     }
13051
13052   return result;
13053 }
13054
13055 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13056    FUNC on it and return the resulting value as a tree with type TYPE.
13057    The mpfr precision is set to the precision of TYPE.  We assume that
13058    function FUNC returns zero if the result could be calculated
13059    exactly within the requested precision.  */
13060
13061 static tree
13062 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13063               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13064 {
13065   tree result = NULL_TREE;
13066
13067   STRIP_NOPS (arg1);
13068   STRIP_NOPS (arg2);
13069   STRIP_NOPS (arg3);
13070
13071   /* To proceed, MPFR must exactly represent the target floating point
13072      format, which only happens when the target base equals two.  */
13073   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13074       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13075       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13076       && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13077     {
13078       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13079       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13080       const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13081
13082       if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13083         {
13084           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13085           const int prec = fmt->p;
13086           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13087           int inexact;
13088           mpfr_t m1, m2, m3;
13089
13090           mpfr_inits2 (prec, m1, m2, m3, NULL);
13091           mpfr_from_real (m1, ra1, GMP_RNDN);
13092           mpfr_from_real (m2, ra2, GMP_RNDN);
13093           mpfr_from_real (m3, ra3, GMP_RNDN);
13094           mpfr_clear_flags ();
13095           inexact = func (m1, m1, m2, m3, rnd);
13096           result = do_mpfr_ckconv (m1, type, inexact);
13097           mpfr_clears (m1, m2, m3, NULL);
13098         }
13099     }
13100
13101   return result;
13102 }
13103
13104 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13105    the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13106    If ARG_SINP and ARG_COSP are NULL then the result is returned
13107    as a complex value.
13108    The type is taken from the type of ARG and is used for setting the
13109    precision of the calculation and results.  */
13110
13111 static tree
13112 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13113 {
13114   tree const type = TREE_TYPE (arg);
13115   tree result = NULL_TREE;
13116
13117   STRIP_NOPS (arg);
13118
13119   /* To proceed, MPFR must exactly represent the target floating point
13120      format, which only happens when the target base equals two.  */
13121   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13122       && TREE_CODE (arg) == REAL_CST
13123       && !TREE_OVERFLOW (arg))
13124     {
13125       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13126
13127       if (real_isfinite (ra))
13128         {
13129           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13130           const int prec = fmt->p;
13131           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13132           tree result_s, result_c;
13133           int inexact;
13134           mpfr_t m, ms, mc;
13135
13136           mpfr_inits2 (prec, m, ms, mc, NULL);
13137           mpfr_from_real (m, ra, GMP_RNDN);
13138           mpfr_clear_flags ();
13139           inexact = mpfr_sin_cos (ms, mc, m, rnd);
13140           result_s = do_mpfr_ckconv (ms, type, inexact);
13141           result_c = do_mpfr_ckconv (mc, type, inexact);
13142           mpfr_clears (m, ms, mc, NULL);
13143           if (result_s && result_c)
13144             {
13145               /* If we are to return in a complex value do so.  */
13146               if (!arg_sinp && !arg_cosp)
13147                 return build_complex (build_complex_type (type),
13148                                       result_c, result_s);
13149
13150               /* Dereference the sin/cos pointer arguments.  */
13151               arg_sinp = build_fold_indirect_ref (arg_sinp);
13152               arg_cosp = build_fold_indirect_ref (arg_cosp);
13153               /* Proceed if valid pointer type were passed in.  */
13154               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13155                   && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13156                 {
13157                   /* Set the values. */
13158                   result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13159                                           result_s);
13160                   TREE_SIDE_EFFECTS (result_s) = 1;
13161                   result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13162                                           result_c);
13163                   TREE_SIDE_EFFECTS (result_c) = 1;
13164                   /* Combine the assignments into a compound expr.  */
13165                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13166                                                     result_s, result_c));
13167                 }
13168             }
13169         }
13170     }
13171   return result;
13172 }
13173
13174 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13175    two-argument mpfr order N Bessel function FUNC on them and return
13176    the resulting value as a tree with type TYPE.  The mpfr precision
13177    is set to the precision of TYPE.  We assume that function FUNC
13178    returns zero if the result could be calculated exactly within the
13179    requested precision.  */
13180 static tree
13181 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13182                   int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13183                   const REAL_VALUE_TYPE *min, bool inclusive)
13184 {
13185   tree result = NULL_TREE;
13186
13187   STRIP_NOPS (arg1);
13188   STRIP_NOPS (arg2);
13189
13190   /* To proceed, MPFR must exactly represent the target floating point
13191      format, which only happens when the target base equals two.  */
13192   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13193       && host_integerp (arg1, 0)
13194       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13195     {
13196       const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13197       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13198
13199       if (n == (long)n
13200           && real_isfinite (ra)
13201           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13202         {
13203           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13204           const int prec = fmt->p;
13205           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13206           int inexact;
13207           mpfr_t m;
13208
13209           mpfr_init2 (m, prec);
13210           mpfr_from_real (m, ra, GMP_RNDN);
13211           mpfr_clear_flags ();
13212           inexact = func (m, n, m, rnd);
13213           result = do_mpfr_ckconv (m, type, inexact);
13214           mpfr_clear (m);
13215         }
13216     }
13217
13218   return result;
13219 }
13220
13221 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13222    the pointer *(ARG_QUO) and return the result.  The type is taken
13223    from the type of ARG0 and is used for setting the precision of the
13224    calculation and results.  */
13225
13226 static tree
13227 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13228 {
13229   tree const type = TREE_TYPE (arg0);
13230   tree result = NULL_TREE;
13231
13232   STRIP_NOPS (arg0);
13233   STRIP_NOPS (arg1);
13234
13235   /* To proceed, MPFR must exactly represent the target floating point
13236      format, which only happens when the target base equals two.  */
13237   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13238       && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13239       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13240     {
13241       const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13242       const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13243
13244       if (real_isfinite (ra0) && real_isfinite (ra1))
13245         {
13246           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13247           const int prec = fmt->p;
13248           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13249           tree result_rem;
13250           long integer_quo;
13251           mpfr_t m0, m1;
13252
13253           mpfr_inits2 (prec, m0, m1, NULL);
13254           mpfr_from_real (m0, ra0, GMP_RNDN);
13255           mpfr_from_real (m1, ra1, GMP_RNDN);
13256           mpfr_clear_flags ();
13257           mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13258           /* Remquo is independent of the rounding mode, so pass
13259              inexact=0 to do_mpfr_ckconv().  */
13260           result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13261           mpfr_clears (m0, m1, NULL);
13262           if (result_rem)
13263             {
13264               /* MPFR calculates quo in the host's long so it may
13265                  return more bits in quo than the target int can hold
13266                  if sizeof(host long) > sizeof(target int).  This can
13267                  happen even for native compilers in LP64 mode.  In
13268                  these cases, modulo the quo value with the largest
13269                  number that the target int can hold while leaving one
13270                  bit for the sign.  */
13271               if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13272                 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13273
13274               /* Dereference the quo pointer argument.  */
13275               arg_quo = build_fold_indirect_ref (arg_quo);
13276               /* Proceed iff a valid pointer type was passed in.  */
13277               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13278                 {
13279                   /* Set the value. */
13280                   tree result_quo = fold_build2 (MODIFY_EXPR,
13281                                                  TREE_TYPE (arg_quo), arg_quo,
13282                                                  build_int_cst (NULL, integer_quo));
13283                   TREE_SIDE_EFFECTS (result_quo) = 1;
13284                   /* Combine the quo assignment with the rem.  */
13285                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13286                                                     result_quo, result_rem));
13287                 }
13288             }
13289         }
13290     }
13291   return result;
13292 }
13293
13294 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13295    resulting value as a tree with type TYPE.  The mpfr precision is
13296    set to the precision of TYPE.  We assume that this mpfr function
13297    returns zero if the result could be calculated exactly within the
13298    requested precision.  In addition, the integer pointer represented
13299    by ARG_SG will be dereferenced and set to the appropriate signgam
13300    (-1,1) value.  */
13301
13302 static tree
13303 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13304 {
13305   tree result = NULL_TREE;
13306
13307   STRIP_NOPS (arg);
13308
13309   /* To proceed, MPFR must exactly represent the target floating point
13310      format, which only happens when the target base equals two.  Also
13311      verify ARG is a constant and that ARG_SG is an int pointer.  */
13312   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13313       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13314       && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13315       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13316     {
13317       const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13318
13319       /* In addition to NaN and Inf, the argument cannot be zero or a
13320          negative integer.  */
13321       if (real_isfinite (ra)
13322           && ra->cl != rvc_zero
13323           && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13324         {
13325           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13326           const int prec = fmt->p;
13327           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13328           int inexact, sg;
13329           mpfr_t m;
13330           tree result_lg;
13331
13332           mpfr_init2 (m, prec);
13333           mpfr_from_real (m, ra, GMP_RNDN);
13334           mpfr_clear_flags ();
13335           inexact = mpfr_lgamma (m, &sg, m, rnd);
13336           result_lg = do_mpfr_ckconv (m, type, inexact);
13337           mpfr_clear (m);
13338           if (result_lg)
13339             {
13340               tree result_sg;
13341
13342               /* Dereference the arg_sg pointer argument.  */
13343               arg_sg = build_fold_indirect_ref (arg_sg);
13344               /* Assign the signgam value into *arg_sg. */
13345               result_sg = fold_build2 (MODIFY_EXPR,
13346                                        TREE_TYPE (arg_sg), arg_sg,
13347                                        build_int_cst (NULL, sg));
13348               TREE_SIDE_EFFECTS (result_sg) = 1;
13349               /* Combine the signgam assignment with the lgamma result.  */
13350               result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13351                                                 result_sg, result_lg));
13352             }
13353         }
13354     }
13355
13356   return result;
13357 }
13358
13359 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13360    function FUNC on it and return the resulting value as a tree with
13361    type TYPE.  The mpfr precision is set to the precision of TYPE.  We
13362    assume that function FUNC returns zero if the result could be
13363    calculated exactly within the requested precision.  */
13364
13365 static tree
13366 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13367 {
13368   tree result = NULL_TREE;
13369
13370   STRIP_NOPS (arg);
13371
13372   /* To proceed, MPFR must exactly represent the target floating point
13373      format, which only happens when the target base equals two.  */
13374   if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
13375       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
13376       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
13377     {
13378       const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
13379       const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
13380
13381       if (real_isfinite (re) && real_isfinite (im))
13382         {
13383           const struct real_format *const fmt =
13384             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13385           const int prec = fmt->p;
13386           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13387           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13388           int inexact;
13389           mpc_t m;
13390
13391           mpc_init2 (m, prec);
13392           mpfr_from_real (mpc_realref(m), re, rnd);
13393           mpfr_from_real (mpc_imagref(m), im, rnd);
13394           mpfr_clear_flags ();
13395           inexact = func (m, m, crnd);
13396           result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
13397           mpc_clear (m);
13398         }
13399     }
13400
13401   return result;
13402 }
13403
13404 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
13405    mpc function FUNC on it and return the resulting value as a tree
13406    with type TYPE.  The mpfr precision is set to the precision of
13407    TYPE.  We assume that function FUNC returns zero if the result
13408    could be calculated exactly within the requested precision.  If
13409    DO_NONFINITE is true, then fold expressions containing Inf or NaN
13410    in the arguments and/or results.  */
13411
13412 tree
13413 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
13414              int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
13415 {
13416   tree result = NULL_TREE;
13417
13418   STRIP_NOPS (arg0);
13419   STRIP_NOPS (arg1);
13420
13421   /* To proceed, MPFR must exactly represent the target floating point
13422      format, which only happens when the target base equals two.  */
13423   if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
13424       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
13425       && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
13426       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
13427       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
13428     {
13429       const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
13430       const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
13431       const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
13432       const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
13433
13434       if (do_nonfinite
13435           || (real_isfinite (re0) && real_isfinite (im0)
13436               && real_isfinite (re1) && real_isfinite (im1)))
13437         {
13438           const struct real_format *const fmt =
13439             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13440           const int prec = fmt->p;
13441           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13442           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13443           int inexact;
13444           mpc_t m0, m1;
13445
13446           mpc_init2 (m0, prec);
13447           mpc_init2 (m1, prec);
13448           mpfr_from_real (mpc_realref(m0), re0, rnd);
13449           mpfr_from_real (mpc_imagref(m0), im0, rnd);
13450           mpfr_from_real (mpc_realref(m1), re1, rnd);
13451           mpfr_from_real (mpc_imagref(m1), im1, rnd);
13452           mpfr_clear_flags ();
13453           inexact = func (m0, m0, m1, crnd);
13454           result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
13455           mpc_clear (m0);
13456           mpc_clear (m1);
13457         }
13458     }
13459
13460   return result;
13461 }
13462
13463 /* FIXME tuples.
13464    The functions below provide an alternate interface for folding
13465    builtin function calls presented as GIMPLE_CALL statements rather
13466    than as CALL_EXPRs.  The folded result is still expressed as a
13467    tree.  There is too much code duplication in the handling of
13468    varargs functions, and a more intrusive re-factoring would permit
13469    better sharing of code between the tree and statement-based
13470    versions of these functions.  */
13471
13472 /* Construct a new CALL_EXPR using the tail of the argument list of STMT
13473    along with N new arguments specified as the "..." parameters.  SKIP
13474    is the number of arguments in STMT to be omitted.  This function is used
13475    to do varargs-to-varargs transformations.  */
13476
13477 static tree
13478 gimple_rewrite_call_expr (gimple stmt, int skip, tree fndecl, int n, ...)
13479 {
13480   int oldnargs = gimple_call_num_args (stmt);
13481   int nargs = oldnargs - skip + n;
13482   tree fntype = TREE_TYPE (fndecl);
13483   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
13484   tree *buffer;
13485   int i, j;
13486   va_list ap;
13487   location_t loc = gimple_location (stmt);
13488
13489   buffer = XALLOCAVEC (tree, nargs);
13490   va_start (ap, n);
13491   for (i = 0; i < n; i++)
13492     buffer[i] = va_arg (ap, tree);
13493   va_end (ap);
13494   for (j = skip; j < oldnargs; j++, i++)
13495     buffer[i] = gimple_call_arg (stmt, j);
13496
13497   return fold (build_call_array_loc (loc, TREE_TYPE (fntype), fn, nargs, buffer));
13498 }
13499
13500 /* Fold a call STMT to __{,v}sprintf_chk.  Return NULL_TREE if
13501    a normal call should be emitted rather than expanding the function
13502    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
13503
13504 static tree
13505 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
13506 {
13507   tree dest, size, len, fn, fmt, flag;
13508   const char *fmt_str;
13509   int nargs = gimple_call_num_args (stmt);
13510
13511   /* Verify the required arguments in the original call.  */
13512   if (nargs < 4)
13513     return NULL_TREE;
13514   dest = gimple_call_arg (stmt, 0);
13515   if (!validate_arg (dest, POINTER_TYPE))
13516     return NULL_TREE;
13517   flag = gimple_call_arg (stmt, 1);
13518   if (!validate_arg (flag, INTEGER_TYPE))
13519     return NULL_TREE;
13520   size = gimple_call_arg (stmt, 2);
13521   if (!validate_arg (size, INTEGER_TYPE))
13522     return NULL_TREE;
13523   fmt = gimple_call_arg (stmt, 3);
13524   if (!validate_arg (fmt, POINTER_TYPE))
13525     return NULL_TREE;
13526
13527   if (! host_integerp (size, 1))
13528     return NULL_TREE;
13529
13530   len = NULL_TREE;
13531
13532   if (!init_target_chars ())
13533     return NULL_TREE;
13534
13535   /* Check whether the format is a literal string constant.  */
13536   fmt_str = c_getstr (fmt);
13537   if (fmt_str != NULL)
13538     {
13539       /* If the format doesn't contain % args or %%, we know the size.  */
13540       if (strchr (fmt_str, target_percent) == 0)
13541         {
13542           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
13543             len = build_int_cstu (size_type_node, strlen (fmt_str));
13544         }
13545       /* If the format is "%s" and first ... argument is a string literal,
13546          we know the size too.  */
13547       else if (fcode == BUILT_IN_SPRINTF_CHK
13548                && strcmp (fmt_str, target_percent_s) == 0)
13549         {
13550           tree arg;
13551
13552           if (nargs == 5)
13553             {
13554               arg = gimple_call_arg (stmt, 4);
13555               if (validate_arg (arg, POINTER_TYPE))
13556                 {
13557                   len = c_strlen (arg, 1);
13558                   if (! len || ! host_integerp (len, 1))
13559                     len = NULL_TREE;
13560                 }
13561             }
13562         }
13563     }
13564
13565   if (! integer_all_onesp (size))
13566     {
13567       if (! len || ! tree_int_cst_lt (len, size))
13568         return NULL_TREE;
13569     }
13570
13571   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13572      or if format doesn't contain % chars or is "%s".  */
13573   if (! integer_zerop (flag))
13574     {
13575       if (fmt_str == NULL)
13576         return NULL_TREE;
13577       if (strchr (fmt_str, target_percent) != NULL
13578           && strcmp (fmt_str, target_percent_s))
13579         return NULL_TREE;
13580     }
13581
13582   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
13583   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
13584                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
13585   if (!fn)
13586     return NULL_TREE;
13587
13588   return gimple_rewrite_call_expr (stmt, 4, fn, 2, dest, fmt);
13589 }
13590
13591 /* Fold a call STMT to {,v}snprintf.  Return NULL_TREE if
13592    a normal call should be emitted rather than expanding the function
13593    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
13594    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
13595    passed as second argument.  */
13596
13597 tree
13598 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
13599                                   enum built_in_function fcode)
13600 {
13601   tree dest, size, len, fn, fmt, flag;
13602   const char *fmt_str;
13603
13604   /* Verify the required arguments in the original call.  */
13605   if (gimple_call_num_args (stmt) < 5)
13606     return NULL_TREE;
13607   dest = gimple_call_arg (stmt, 0);
13608   if (!validate_arg (dest, POINTER_TYPE))
13609     return NULL_TREE;
13610   len = gimple_call_arg (stmt, 1);
13611   if (!validate_arg (len, INTEGER_TYPE))
13612     return NULL_TREE;
13613   flag = gimple_call_arg (stmt, 2);
13614   if (!validate_arg (flag, INTEGER_TYPE))
13615     return NULL_TREE;
13616   size = gimple_call_arg (stmt, 3);
13617   if (!validate_arg (size, INTEGER_TYPE))
13618     return NULL_TREE;
13619   fmt = gimple_call_arg (stmt, 4);
13620   if (!validate_arg (fmt, POINTER_TYPE))
13621     return NULL_TREE;
13622
13623   if (! host_integerp (size, 1))
13624     return NULL_TREE;
13625
13626   if (! integer_all_onesp (size))
13627     {
13628       if (! host_integerp (len, 1))
13629         {
13630           /* If LEN is not constant, try MAXLEN too.
13631              For MAXLEN only allow optimizing into non-_ocs function
13632              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
13633           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
13634             return NULL_TREE;
13635         }
13636       else
13637         maxlen = len;
13638
13639       if (tree_int_cst_lt (size, maxlen))
13640         return NULL_TREE;
13641     }
13642
13643   if (!init_target_chars ())
13644     return NULL_TREE;
13645
13646   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13647      or if format doesn't contain % chars or is "%s".  */
13648   if (! integer_zerop (flag))
13649     {
13650       fmt_str = c_getstr (fmt);
13651       if (fmt_str == NULL)
13652         return NULL_TREE;
13653       if (strchr (fmt_str, target_percent) != NULL
13654           && strcmp (fmt_str, target_percent_s))
13655         return NULL_TREE;
13656     }
13657
13658   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13659      available.  */
13660   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
13661                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
13662   if (!fn)
13663     return NULL_TREE;
13664
13665   return gimple_rewrite_call_expr (stmt, 5, fn, 3, dest, len, fmt);
13666 }
13667
13668 /* Builtins with folding operations that operate on "..." arguments
13669    need special handling; we need to store the arguments in a convenient
13670    data structure before attempting any folding.  Fortunately there are
13671    only a few builtins that fall into this category.  FNDECL is the
13672    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13673    result of the function call is ignored.  */
13674
13675 static tree
13676 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
13677                              bool ignore ATTRIBUTE_UNUSED)
13678 {
13679   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13680   tree ret = NULL_TREE;
13681
13682   switch (fcode)
13683     {
13684     case BUILT_IN_SPRINTF_CHK:
13685     case BUILT_IN_VSPRINTF_CHK:
13686       ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
13687       break;
13688
13689     case BUILT_IN_SNPRINTF_CHK:
13690     case BUILT_IN_VSNPRINTF_CHK:
13691       ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
13692
13693     default:
13694       break;
13695     }
13696   if (ret)
13697     {
13698       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
13699       TREE_NO_WARNING (ret) = 1;
13700       return ret;
13701     }
13702   return NULL_TREE;
13703 }
13704
13705 /* A wrapper function for builtin folding that prevents warnings for
13706    "statement without effect" and the like, caused by removing the
13707    call node earlier than the warning is generated.  */
13708
13709 tree
13710 fold_call_stmt (gimple stmt, bool ignore)
13711 {
13712   tree ret = NULL_TREE;
13713   tree fndecl = gimple_call_fndecl (stmt);
13714   location_t loc = gimple_location (stmt);
13715   if (fndecl
13716       && TREE_CODE (fndecl) == FUNCTION_DECL
13717       && DECL_BUILT_IN (fndecl)
13718       && !gimple_call_va_arg_pack_p (stmt))
13719     {
13720       int nargs = gimple_call_num_args (stmt);
13721
13722       if (avoid_folding_inline_builtin (fndecl))
13723         return NULL_TREE;
13724       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
13725         {
13726           return targetm.fold_builtin (fndecl, nargs,
13727                                        (nargs > 0
13728                                         ? gimple_call_arg_ptr (stmt, 0)
13729                                         : &error_mark_node), ignore);
13730         }
13731       else
13732         {
13733           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
13734             {
13735               tree args[MAX_ARGS_TO_FOLD_BUILTIN];
13736               int i;
13737               for (i = 0; i < nargs; i++)
13738                 args[i] = gimple_call_arg (stmt, i);
13739               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
13740             }
13741           if (!ret)
13742             ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
13743           if (ret)
13744             {
13745               /* Propagate location information from original call to
13746                  expansion of builtin.  Otherwise things like
13747                  maybe_emit_chk_warning, that operate on the expansion
13748                  of a builtin, will use the wrong location information.  */
13749               if (gimple_has_location (stmt))
13750                 {
13751                   tree realret = ret;
13752                   if (TREE_CODE (ret) == NOP_EXPR)
13753                     realret = TREE_OPERAND (ret, 0);
13754                   if (CAN_HAVE_LOCATION_P (realret)
13755                       && !EXPR_HAS_LOCATION (realret))
13756                     SET_EXPR_LOCATION (realret, loc);
13757                   return realret;
13758                 }
13759               return ret;
13760             }
13761         }
13762     }
13763   return NULL_TREE;
13764 }
13765
13766 /* Look up the function in built_in_decls that corresponds to DECL
13767    and set ASMSPEC as its user assembler name.  DECL must be a
13768    function decl that declares a builtin.  */
13769
13770 void
13771 set_builtin_user_assembler_name (tree decl, const char *asmspec)
13772 {
13773   tree builtin;
13774   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
13775               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
13776               && asmspec != 0);
13777
13778   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
13779   set_user_assembler_name (builtin, asmspec);
13780   switch (DECL_FUNCTION_CODE (decl))
13781     {
13782     case BUILT_IN_MEMCPY:
13783       init_block_move_fn (asmspec);
13784       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
13785       break;
13786     case BUILT_IN_MEMSET:
13787       init_block_clear_fn (asmspec);
13788       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
13789       break;
13790     case BUILT_IN_MEMMOVE:
13791       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
13792       break;
13793     case BUILT_IN_MEMCMP:
13794       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
13795       break;
13796     case BUILT_IN_ABORT:
13797       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
13798       break;
13799     case BUILT_IN_FFS:
13800       if (INT_TYPE_SIZE < BITS_PER_WORD)
13801         {
13802           set_user_assembler_libfunc ("ffs", asmspec);
13803           set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
13804                                                        MODE_INT, 0), "ffs");
13805         }
13806       break;
13807     default:
13808       break;
13809     }
13810 }
13811
13812 /* Return true if DECL is a builtin that expands to a constant or similarly
13813    simple code.  */
13814 bool
13815 is_simple_builtin (tree decl)
13816 {
13817   if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13818     switch (DECL_FUNCTION_CODE (decl))
13819       {
13820         /* Builtins that expand to constants.  */
13821       case BUILT_IN_CONSTANT_P:
13822       case BUILT_IN_EXPECT:
13823       case BUILT_IN_OBJECT_SIZE:
13824       case BUILT_IN_UNREACHABLE:
13825         /* Simple register moves or loads from stack.  */
13826       case BUILT_IN_RETURN_ADDRESS:
13827       case BUILT_IN_EXTRACT_RETURN_ADDR:
13828       case BUILT_IN_FROB_RETURN_ADDR:
13829       case BUILT_IN_RETURN:
13830       case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
13831       case BUILT_IN_FRAME_ADDRESS:
13832       case BUILT_IN_VA_END:
13833       case BUILT_IN_STACK_SAVE:
13834       case BUILT_IN_STACK_RESTORE:
13835         /* Exception state returns or moves registers around.  */
13836       case BUILT_IN_EH_FILTER:
13837       case BUILT_IN_EH_POINTER:
13838       case BUILT_IN_EH_COPY_VALUES:
13839         return true;
13840
13841       default:
13842         return false;
13843       }
13844
13845   return false;
13846 }
13847
13848 /* Return true if DECL is a builtin that is not expensive, i.e., they are
13849    most probably expanded inline into reasonably simple code.  This is a
13850    superset of is_simple_builtin.  */
13851 bool
13852 is_inexpensive_builtin (tree decl)
13853 {
13854   if (!decl)
13855     return false;
13856   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
13857     return true;
13858   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13859     switch (DECL_FUNCTION_CODE (decl))
13860       {
13861       case BUILT_IN_ABS:
13862       case BUILT_IN_ALLOCA:
13863       case BUILT_IN_BSWAP32:
13864       case BUILT_IN_BSWAP64:
13865       case BUILT_IN_CLZ:
13866       case BUILT_IN_CLZIMAX:
13867       case BUILT_IN_CLZL:
13868       case BUILT_IN_CLZLL:
13869       case BUILT_IN_CTZ:
13870       case BUILT_IN_CTZIMAX:
13871       case BUILT_IN_CTZL:
13872       case BUILT_IN_CTZLL:
13873       case BUILT_IN_FFS:
13874       case BUILT_IN_FFSIMAX:
13875       case BUILT_IN_FFSL:
13876       case BUILT_IN_FFSLL:
13877       case BUILT_IN_IMAXABS:
13878       case BUILT_IN_FINITE:
13879       case BUILT_IN_FINITEF:
13880       case BUILT_IN_FINITEL:
13881       case BUILT_IN_FINITED32:
13882       case BUILT_IN_FINITED64:
13883       case BUILT_IN_FINITED128:
13884       case BUILT_IN_FPCLASSIFY:
13885       case BUILT_IN_ISFINITE:
13886       case BUILT_IN_ISINF_SIGN:
13887       case BUILT_IN_ISINF:
13888       case BUILT_IN_ISINFF:
13889       case BUILT_IN_ISINFL:
13890       case BUILT_IN_ISINFD32:
13891       case BUILT_IN_ISINFD64:
13892       case BUILT_IN_ISINFD128:
13893       case BUILT_IN_ISNAN:
13894       case BUILT_IN_ISNANF:
13895       case BUILT_IN_ISNANL:
13896       case BUILT_IN_ISNAND32:
13897       case BUILT_IN_ISNAND64:
13898       case BUILT_IN_ISNAND128:
13899       case BUILT_IN_ISNORMAL:
13900       case BUILT_IN_ISGREATER:
13901       case BUILT_IN_ISGREATEREQUAL:
13902       case BUILT_IN_ISLESS:
13903       case BUILT_IN_ISLESSEQUAL:
13904       case BUILT_IN_ISLESSGREATER:
13905       case BUILT_IN_ISUNORDERED:
13906       case BUILT_IN_VA_ARG_PACK:
13907       case BUILT_IN_VA_ARG_PACK_LEN:
13908       case BUILT_IN_VA_COPY:
13909       case BUILT_IN_TRAP:
13910       case BUILT_IN_SAVEREGS:
13911       case BUILT_IN_POPCOUNTL:
13912       case BUILT_IN_POPCOUNTLL:
13913       case BUILT_IN_POPCOUNTIMAX:
13914       case BUILT_IN_POPCOUNT:
13915       case BUILT_IN_PARITYL:
13916       case BUILT_IN_PARITYLL:
13917       case BUILT_IN_PARITYIMAX:
13918       case BUILT_IN_PARITY:
13919       case BUILT_IN_LABS:
13920       case BUILT_IN_LLABS:
13921       case BUILT_IN_PREFETCH:
13922         return true;
13923
13924       default:
13925         return is_simple_builtin (decl);
13926       }
13927
13928   return false;
13929 }
13930