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
   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 "real.h"
  28 #include "rtl.h"
  29 #include "tree.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.h"
  53
  54 #ifndef SLOW_UNALIGNED_ACCESS
  55 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
  56 #endif
  57
  58 #ifndef PAD_VARARGS_DOWN
  59 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
  60 #endif
  61 #ifdef HAVE_mpc
  62 static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));
  63 #endif
  64
  65 /* Define the names of the builtin function types and codes.  */
  66 const char *const built_in_class_names[4]
  67   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
  68
  69 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
  70 const char * built_in_names[(int) END_BUILTINS] =
  71 {
  72 #include "builtins.def"
  73 };
  74 #undef DEF_BUILTIN
  75
  76 /* Setup an array of _DECL trees, make sure each element is
  77    initialized to NULL_TREE.  */
  78 tree built_in_decls[(int) END_BUILTINS];
  79 /* Declarations used when constructing the builtin implicitly in the compiler.
  80    It may be NULL_TREE when this is invalid (for instance runtime is not
  81    required to implement the function call in all cases).  */
  82 tree implicit_built_in_decls[(int) END_BUILTINS];
  83
  84 static const char *c_getstr (tree);
  85 static rtx c_readstr (const char *, enum machine_mode);
  86 static int target_char_cast (tree, char *);
  87 static rtx get_memory_rtx (tree, tree);
  88 static int apply_args_size (void);
  89 static int apply_result_size (void);
  90 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
  91 static rtx result_vector (int, rtx);
  92 #endif
  93 static void expand_builtin_update_setjmp_buf (rtx);
  94 static void expand_builtin_prefetch (tree);
  95 static rtx expand_builtin_apply_args (void);
  96 static rtx expand_builtin_apply_args_1 (void);
  97 static rtx expand_builtin_apply (rtx, rtx, rtx);
  98 static void expand_builtin_return (rtx);
  99 static enum type_class type_to_class (tree);
 100 static rtx expand_builtin_classify_type (tree);
 101 static void expand_errno_check (tree, rtx);
 102 static rtx expand_builtin_mathfn (tree, rtx, rtx);
 103 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
 104 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
 105 static rtx expand_builtin_interclass_mathfn (tree, rtx, rtx);
 106 static rtx expand_builtin_sincos (tree);
 107 static rtx expand_builtin_cexpi (tree, rtx, rtx);
 108 static rtx expand_builtin_int_roundingfn (tree, rtx);
 109 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
 110 static rtx expand_builtin_args_info (tree);
 111 static rtx expand_builtin_next_arg (void);
 112 static rtx expand_builtin_va_start (tree);
 113 static rtx expand_builtin_va_end (tree);
 114 static rtx expand_builtin_va_copy (tree);
 115 static rtx expand_builtin_memchr (tree, rtx, enum machine_mode);
 116 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
 117 static rtx expand_builtin_strcmp (tree, rtx, enum machine_mode);
 118 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
 119 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 120 static rtx expand_builtin_strcat (tree, tree, rtx, enum machine_mode);
 121 static rtx expand_builtin_strncat (tree, rtx, enum machine_mode);
 122 static rtx expand_builtin_strspn (tree, rtx, enum machine_mode);
 123 static rtx expand_builtin_strcspn (tree, rtx, enum machine_mode);
 124 static rtx expand_builtin_memcpy (tree, rtx, enum machine_mode);
 125 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
 126 static rtx expand_builtin_mempcpy_args (tree, tree, tree, tree, rtx,
 127                                         enum machine_mode, int);
 128 static rtx expand_builtin_memmove (tree, rtx, enum machine_mode, int);
 129 static rtx expand_builtin_memmove_args (tree, tree, tree, tree, rtx,
 130                                         enum machine_mode, int);
 131 static rtx expand_builtin_bcopy (tree, int);
 132 static rtx expand_builtin_strcpy (tree, tree, rtx, enum machine_mode);
 133 static rtx expand_builtin_strcpy_args (tree, tree, tree, rtx, enum machine_mode);
 134 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
 135 static rtx expand_builtin_strncpy (tree, rtx, enum machine_mode);
 136 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
 137 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
 138 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
 139 static rtx expand_builtin_bzero (tree);
 140 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
 141 static rtx expand_builtin_strstr (tree, rtx, enum machine_mode);
 142 static rtx expand_builtin_strpbrk (tree, rtx, enum machine_mode);
 143 static rtx expand_builtin_strchr (tree, rtx, enum machine_mode);
 144 static rtx expand_builtin_strrchr (tree, rtx, enum machine_mode);
 145 static rtx expand_builtin_alloca (tree, rtx);
 146 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
 147 static rtx expand_builtin_frame_address (tree, tree);
 148 static rtx expand_builtin_fputs (tree, rtx, bool);
 149 static rtx expand_builtin_printf (tree, rtx, enum machine_mode, bool);
 150 static rtx expand_builtin_fprintf (tree, rtx, enum machine_mode, bool);
 151 static rtx expand_builtin_sprintf (tree, rtx, enum machine_mode);
 152 static tree stabilize_va_list (tree, int);
 153 static rtx expand_builtin_expect (tree, rtx);
 154 static tree fold_builtin_constant_p (tree);
 155 static tree fold_builtin_expect (tree, tree);
 156 static tree fold_builtin_classify_type (tree);
 157 static tree fold_builtin_strlen (tree);
 158 static tree fold_builtin_inf (tree, int);
 159 static tree fold_builtin_nan (tree, tree, int);
 160 static tree rewrite_call_expr (tree, int, tree, int, ...);
 161 static bool validate_arg (const_tree, enum tree_code code);
 162 static bool integer_valued_real_p (tree);
 163 static tree fold_trunc_transparent_mathfn (tree, tree);
 164 static bool readonly_data_expr (tree);
 165 static rtx expand_builtin_fabs (tree, rtx, rtx);
 166 static rtx expand_builtin_signbit (tree, rtx);
 167 static tree fold_builtin_sqrt (tree, tree);
 168 static tree fold_builtin_cbrt (tree, tree);
 169 static tree fold_builtin_pow (tree, tree, tree, tree);
 170 static tree fold_builtin_powi (tree, tree, tree, tree);
 171 static tree fold_builtin_cos (tree, tree, tree);
 172 static tree fold_builtin_cosh (tree, tree, tree);
 173 static tree fold_builtin_tan (tree, tree);
 174 static tree fold_builtin_trunc (tree, tree);
 175 static tree fold_builtin_floor (tree, tree);
 176 static tree fold_builtin_ceil (tree, tree);
 177 static tree fold_builtin_round (tree, tree);
 178 static tree fold_builtin_int_roundingfn (tree, tree);
 179 static tree fold_builtin_bitop (tree, tree);
 180 static tree fold_builtin_memory_op (tree, tree, tree, tree, bool, int);
 181 static tree fold_builtin_strchr (tree, tree, tree);
 182 static tree fold_builtin_memchr (tree, tree, tree, tree);
 183 static tree fold_builtin_memcmp (tree, tree, tree);
 184 static tree fold_builtin_strcmp (tree, tree);
 185 static tree fold_builtin_strncmp (tree, tree, tree);
 186 static tree fold_builtin_signbit (tree, tree);
 187 static tree fold_builtin_copysign (tree, tree, tree, tree);
 188 static tree fold_builtin_isascii (tree);
 189 static tree fold_builtin_toascii (tree);
 190 static tree fold_builtin_isdigit (tree);
 191 static tree fold_builtin_fabs (tree, tree);
 192 static tree fold_builtin_abs (tree, tree);
 193 static tree fold_builtin_unordered_cmp (tree, tree, tree, enum tree_code,
 194                                         enum tree_code);
 195 static tree fold_builtin_n (tree, tree *, int, bool);
 196 static tree fold_builtin_0 (tree, bool);
 197 static tree fold_builtin_1 (tree, tree, bool);
 198 static tree fold_builtin_2 (tree, tree, tree, bool);
 199 static tree fold_builtin_3 (tree, tree, tree, tree, bool);
 200 static tree fold_builtin_4 (tree, tree, tree, tree, tree, bool);
 201 static tree fold_builtin_varargs (tree, tree, bool);
 202
 203 static tree fold_builtin_strpbrk (tree, tree, tree);
 204 static tree fold_builtin_strstr (tree, tree, tree);
 205 static tree fold_builtin_strrchr (tree, tree, tree);
 206 static tree fold_builtin_strcat (tree, tree);
 207 static tree fold_builtin_strncat (tree, tree, tree);
 208 static tree fold_builtin_strspn (tree, tree);
 209 static tree fold_builtin_strcspn (tree, tree);
 210 static tree fold_builtin_sprintf (tree, tree, tree, int);
 211
 212 static rtx expand_builtin_object_size (tree);
 213 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
 214                                       enum built_in_function);
 215 static void maybe_emit_chk_warning (tree, enum built_in_function);
 216 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 217 static void maybe_emit_free_warning (tree);
 218 static tree fold_builtin_object_size (tree, tree);
 219 static tree fold_builtin_strcat_chk (tree, tree, tree, tree);
 220 static tree fold_builtin_strncat_chk (tree, tree, tree, tree, tree);
 221 static tree fold_builtin_sprintf_chk (tree, enum built_in_function);
 222 static tree fold_builtin_printf (tree, tree, tree, bool, enum built_in_function);
 223 static tree fold_builtin_fprintf (tree, tree, tree, tree, bool,
 224                                   enum built_in_function);
 225 static bool init_target_chars (void);
 226
 227 static unsigned HOST_WIDE_INT target_newline;
 228 static unsigned HOST_WIDE_INT target_percent;
 229 static unsigned HOST_WIDE_INT target_c;
 230 static unsigned HOST_WIDE_INT target_s;
 231 static char target_percent_c[3];
 232 static char target_percent_s[3];
 233 static char target_percent_s_newline[4];
 234 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
 235                           const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
 236 static tree do_mpfr_arg2 (tree, tree, tree,
 237                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 238 static tree do_mpfr_arg3 (tree, tree, tree, tree,
 239                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 240 static tree do_mpfr_sincos (tree, tree, tree);
 241 static tree do_mpfr_bessel_n (tree, tree, tree,
 242                               int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
 243                               const REAL_VALUE_TYPE *, bool);
 244 static tree do_mpfr_remquo (tree, tree, tree);
 245 static tree do_mpfr_lgamma_r (tree, tree, tree);
 246
 247 bool
 248 is_builtin_name (const char *name)
 249 {
 250   if (strncmp (name, "__builtin_", 10) == 0)
 251     return true;
 252   if (strncmp (name, "__sync_", 7) == 0)
 253     return true;
 254   return false;
 255 }
 256
 257 /* Return true if NODE should be considered for inline expansion regardless
 258    of the optimization level.  This means whenever a function is invoked with
 259    its "internal" name, which normally contains the prefix "__builtin".  */
 260
 261 static bool
 262 called_as_built_in (tree node)
 263 {
 264   /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
 265      we want the name used to call the function, not the name it
 266      will have. */
 267   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 268   return is_builtin_name (name);
 269 }
 270
 271 /* Return the alignment in bits of EXP, an object.
 272    Don't return more than MAX_ALIGN no matter what, ALIGN is the inital
 273    guessed alignment e.g. from type alignment.  */
 274
 275 int
 276 get_object_alignment (tree exp, unsigned int align, unsigned int max_align)
 277 {
 278   unsigned int inner;
 279
 280   inner = max_align;
 281   if (handled_component_p (exp))
 282    {
 283       HOST_WIDE_INT bitsize, bitpos;
 284       tree offset;
 285       enum machine_mode mode;
 286       int unsignedp, volatilep;
 287
 288       exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
 289                                  &mode, &unsignedp, &volatilep, true);
 290       if (bitpos)
 291         inner = MIN (inner, (unsigned) (bitpos & -bitpos));
 292       while (offset)
 293         {
 294           tree next_offset;
 295
 296           if (TREE_CODE (offset) == PLUS_EXPR)
 297             {
 298               next_offset = TREE_OPERAND (offset, 0);
 299               offset = TREE_OPERAND (offset, 1);
 300             }
 301           else
 302             next_offset = NULL;
 303           if (host_integerp (offset, 1))
 304             {
 305               /* Any overflow in calculating offset_bits won't change
 306                  the alignment.  */
 307               unsigned offset_bits
 308                 = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
 309
 310               if (offset_bits)
 311                 inner = MIN (inner, (offset_bits & -offset_bits));
 312             }
 313           else if (TREE_CODE (offset) == MULT_EXPR
 314                    && host_integerp (TREE_OPERAND (offset, 1), 1))
 315             {
 316               /* Any overflow in calculating offset_factor won't change
 317                  the alignment.  */
 318               unsigned offset_factor
 319                 = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
 320                    * BITS_PER_UNIT);
 321
 322               if (offset_factor)
 323                 inner = MIN (inner, (offset_factor & -offset_factor));
 324             }
 325           else
 326             {
 327               inner = MIN (inner, BITS_PER_UNIT);
 328               break;
 329             }
 330           offset = next_offset;
 331         }
 332     }
 333   if (DECL_P (exp))
 334     align = MIN (inner, DECL_ALIGN (exp));
 335 #ifdef CONSTANT_ALIGNMENT
 336   else if (CONSTANT_CLASS_P (exp))
 337     align = MIN (inner, (unsigned)CONSTANT_ALIGNMENT (exp, align));
 338 #endif
 339   else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR
 340            || TREE_CODE (exp) == INDIRECT_REF)
 341     align = MIN (TYPE_ALIGN (TREE_TYPE (exp)), inner);
 342   else
 343     align = MIN (align, inner);
 344   return MIN (align, max_align);
 345 }
 346
 347 /* Return the alignment in bits of EXP, a pointer valued expression.
 348    But don't return more than MAX_ALIGN no matter what.
 349    The alignment returned is, by default, the alignment of the thing that
 350    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 351
 352    Otherwise, look at the expression to see if we can do better, i.e., if the
 353    expression is actually pointing at an object whose alignment is tighter.  */
 354
 355 int
 356 get_pointer_alignment (tree exp, unsigned int max_align)
 357 {
 358   unsigned int align, inner;
 359
 360   /* We rely on TER to compute accurate alignment information.  */
 361   if (!(optimize && flag_tree_ter))
 362     return 0;
 363
 364   if (!POINTER_TYPE_P (TREE_TYPE (exp)))
 365     return 0;
 366
 367   align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
 368   align = MIN (align, max_align);
 369
 370   while (1)
 371     {
 372       switch (TREE_CODE (exp))
 373         {
 374         CASE_CONVERT:
 375           exp = TREE_OPERAND (exp, 0);
 376           if (! POINTER_TYPE_P (TREE_TYPE (exp)))
 377             return align;
 378
 379           inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
 380           align = MIN (inner, max_align);
 381           break;
 382
 383         case POINTER_PLUS_EXPR:
 384           /* If sum of pointer + int, restrict our maximum alignment to that
 385              imposed by the integer.  If not, we can't do any better than
 386              ALIGN.  */
 387           if (! host_integerp (TREE_OPERAND (exp, 1), 1))
 388             return align;
 389
 390           while (((tree_low_cst (TREE_OPERAND (exp, 1), 1))
 391                   & (max_align / BITS_PER_UNIT - 1))
 392                  != 0)
 393             max_align >>= 1;
 394
 395           exp = TREE_OPERAND (exp, 0);
 396           break;
 397
 398         case ADDR_EXPR:
 399           /* See what we are pointing at and look at its alignment.  */
 400           return get_object_alignment (TREE_OPERAND (exp, 0), align, max_align);
 401
 402         default:
 403           return align;
 404         }
 405     }
 406 }
 407
 408 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 409    way, because it could contain a zero byte in the middle.
 410    TREE_STRING_LENGTH is the size of the character array, not the string.
 411
 412    ONLY_VALUE should be nonzero if the result is not going to be emitted
 413    into the instruction stream and zero if it is going to be expanded.
 414    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 415    is returned, otherwise NULL, since
 416    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
 417    evaluate the side-effects.
 418
 419    The value returned is of type `ssizetype'.
 420
 421    Unfortunately, string_constant can't access the values of const char
 422    arrays with initializers, so neither can we do so here.  */
 423
 424 tree
 425 c_strlen (tree src, int only_value)
 426 {
 427   tree offset_node;
 428   HOST_WIDE_INT offset;
 429   int max;
 430   const char *ptr;
 431
 432   STRIP_NOPS (src);
 433   if (TREE_CODE (src) == COND_EXPR
 434       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 435     {
 436       tree len1, len2;
 437
 438       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
 439       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
 440       if (tree_int_cst_equal (len1, len2))
 441         return len1;
 442     }
 443
 444   if (TREE_CODE (src) == COMPOUND_EXPR
 445       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 446     return c_strlen (TREE_OPERAND (src, 1), only_value);
 447
 448   src = string_constant (src, &offset_node);
 449   if (src == 0)
 450     return NULL_TREE;
 451
 452   max = TREE_STRING_LENGTH (src) - 1;
 453   ptr = TREE_STRING_POINTER (src);
 454
 455   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 456     {
 457       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 458          compute the offset to the following null if we don't know where to
 459          start searching for it.  */
 460       int i;
 461
 462       for (i = 0; i < max; i++)
 463         if (ptr[i] == 0)
 464           return NULL_TREE;
 465
 466       /* We don't know the starting offset, but we do know that the string
 467          has no internal zero bytes.  We can assume that the offset falls
 468          within the bounds of the string; otherwise, the programmer deserves
 469          what he gets.  Subtract the offset from the length of the string,
 470          and return that.  This would perhaps not be valid if we were dealing
 471          with named arrays in addition to literal string constants.  */
 472
 473       return size_diffop (size_int (max), offset_node);
 474     }
 475
 476   /* We have a known offset into the string.  Start searching there for
 477      a null character if we can represent it as a single HOST_WIDE_INT.  */
 478   if (offset_node == 0)
 479     offset = 0;
 480   else if (! host_integerp (offset_node, 0))
 481     offset = -1;
 482   else
 483     offset = tree_low_cst (offset_node, 0);
 484
 485   /* If the offset is known to be out of bounds, warn, and call strlen at
 486      runtime.  */
 487   if (offset < 0 || offset > max)
 488     {
 489      /* Suppress multiple warnings for propagated constant strings.  */
 490       if (! TREE_NO_WARNING (src))
 491         {
 492           warning (0, "offset outside bounds of constant string");
 493           TREE_NO_WARNING (src) = 1;
 494         }
 495       return NULL_TREE;
 496     }
 497
 498   /* Use strlen to search for the first zero byte.  Since any strings
 499      constructed with build_string will have nulls appended, we win even
 500      if we get handed something like (char[4])"abcd".
 501
 502      Since OFFSET is our starting index into the string, no further
 503      calculation is needed.  */
 504   return ssize_int (strlen (ptr + offset));
 505 }
 506
 507 /* Return a char pointer for a C string if it is a string constant
 508    or sum of string constant and integer constant.  */
 509
 510 static const char *
 511 c_getstr (tree src)
 512 {
 513   tree offset_node;
 514
 515   src = string_constant (src, &offset_node);
 516   if (src == 0)
 517     return 0;
 518
 519   if (offset_node == 0)
 520     return TREE_STRING_POINTER (src);
 521   else if (!host_integerp (offset_node, 1)
 522            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
 523     return 0;
 524
 525   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
 526 }
 527
 528 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
 529    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 530
 531 static rtx
 532 c_readstr (const char *str, enum machine_mode mode)
 533 {
 534   HOST_WIDE_INT c[2];
 535   HOST_WIDE_INT ch;
 536   unsigned int i, j;
 537
 538   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
 539
 540   c[0] = 0;
 541   c[1] = 0;
 542   ch = 1;
 543   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 544     {
 545       j = i;
 546       if (WORDS_BIG_ENDIAN)
 547         j = GET_MODE_SIZE (mode) - i - 1;
 548       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 549           && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
 550         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 551       j *= BITS_PER_UNIT;
 552       gcc_assert (j <= 2 * HOST_BITS_PER_WIDE_INT);
 553
 554       if (ch)
 555         ch = (unsigned char) str[i];
 556       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 557     }
 558   return immed_double_const (c[0], c[1], mode);
 559 }
 560
 561 /* Cast a target constant CST to target CHAR and if that value fits into
 562    host char type, return zero and put that value into variable pointed to by
 563    P.  */
 564
 565 static int
 566 target_char_cast (tree cst, char *p)
 567 {
 568   unsigned HOST_WIDE_INT val, hostval;
 569
 570   if (!host_integerp (cst, 1)
 571       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 572     return 1;
 573
 574   val = tree_low_cst (cst, 1);
 575   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 576     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 577
 578   hostval = val;
 579   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 580     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 581
 582   if (val != hostval)
 583     return 1;
 584
 585   *p = hostval;
 586   return 0;
 587 }
 588
 589 /* Similar to save_expr, but assumes that arbitrary code is not executed
 590    in between the multiple evaluations.  In particular, we assume that a
 591    non-addressable local variable will not be modified.  */
 592
 593 static tree
 594 builtin_save_expr (tree exp)
 595 {
 596   if (TREE_ADDRESSABLE (exp) == 0
 597       && (TREE_CODE (exp) == PARM_DECL
 598           || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
 599     return exp;
 600
 601   return save_expr (exp);
 602 }
 603
 604 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 605    times to get the address of either a higher stack frame, or a return
 606    address located within it (depending on FNDECL_CODE).  */
 607
 608 static rtx
 609 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
 610 {
 611   int i;
 612
 613 #ifdef INITIAL_FRAME_ADDRESS_RTX
 614   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
 615 #else
 616   rtx tem;
 617
 618   /* For a zero count with __builtin_return_address, we don't care what
 619      frame address we return, because target-specific definitions will
 620      override us.  Therefore frame pointer elimination is OK, and using
 621      the soft frame pointer is OK.
 622
 623      For a nonzero count, or a zero count with __builtin_frame_address,
 624      we require a stable offset from the current frame pointer to the
 625      previous one, so we must use the hard frame pointer, and
 626      we must disable frame pointer elimination.  */
 627   if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
 628     tem = frame_pointer_rtx;
 629   else
 630     {
 631       tem = hard_frame_pointer_rtx;
 632
 633       /* Tell reload not to eliminate the frame pointer.  */
 634       crtl->accesses_prior_frames = 1;
 635     }
 636 #endif
 637
 638   /* Some machines need special handling before we can access
 639      arbitrary frames.  For example, on the SPARC, we must first flush
 640      all register windows to the stack.  */
 641 #ifdef SETUP_FRAME_ADDRESSES
 642   if (count > 0)
 643     SETUP_FRAME_ADDRESSES ();
 644 #endif
 645
 646   /* On the SPARC, the return address is not in the frame, it is in a
 647      register.  There is no way to access it off of the current frame
 648      pointer, but it can be accessed off the previous frame pointer by
 649      reading the value from the register window save area.  */
 650 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
 651   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
 652     count--;
 653 #endif
 654
 655   /* Scan back COUNT frames to the specified frame.  */
 656   for (i = 0; i < count; i++)
 657     {
 658       /* Assume the dynamic chain pointer is in the word that the
 659          frame address points to, unless otherwise specified.  */
 660 #ifdef DYNAMIC_CHAIN_ADDRESS
 661       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 662 #endif
 663       tem = memory_address (Pmode, tem);
 664       tem = gen_frame_mem (Pmode, tem);
 665       tem = copy_to_reg (tem);
 666     }
 667
 668   /* For __builtin_frame_address, return what we've got.  But, on
 669      the SPARC for example, we may have to add a bias.  */
 670   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 671 #ifdef FRAME_ADDR_RTX
 672     return FRAME_ADDR_RTX (tem);
 673 #else
 674     return tem;
 675 #endif
 676
 677   /* For __builtin_return_address, get the return address from that frame.  */
 678 #ifdef RETURN_ADDR_RTX
 679   tem = RETURN_ADDR_RTX (count, tem);
 680 #else
 681   tem = memory_address (Pmode,
 682                         plus_constant (tem, GET_MODE_SIZE (Pmode)));
 683   tem = gen_frame_mem (Pmode, tem);
 684 #endif
 685   return tem;
 686 }
 687
 688 /* Alias set used for setjmp buffer.  */
 689 static alias_set_type setjmp_alias_set = -1;
 690
 691 /* Construct the leading half of a __builtin_setjmp call.  Control will
 692    return to RECEIVER_LABEL.  This is also called directly by the SJLJ
 693    exception handling code.  */
 694
 695 void
 696 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 697 {
 698   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 699   rtx stack_save;
 700   rtx mem;
 701
 702   if (setjmp_alias_set == -1)
 703     setjmp_alias_set = new_alias_set ();
 704
 705   buf_addr = convert_memory_address (Pmode, buf_addr);
 706
 707   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 708
 709   /* We store the frame pointer and the address of receiver_label in
 710      the buffer and use the rest of it for the stack save area, which
 711      is machine-dependent.  */
 712
 713   mem = gen_rtx_MEM (Pmode, buf_addr);
 714   set_mem_alias_set (mem, setjmp_alias_set);
 715   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
 716
 717   mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
 718   set_mem_alias_set (mem, setjmp_alias_set);
 719
 720   emit_move_insn (validize_mem (mem),
 721                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 722
 723   stack_save = gen_rtx_MEM (sa_mode,
 724                             plus_constant (buf_addr,
 725                                            2 * GET_MODE_SIZE (Pmode)));
 726   set_mem_alias_set (stack_save, setjmp_alias_set);
 727   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
 728
 729   /* If there is further processing to do, do it.  */
 730 #ifdef HAVE_builtin_setjmp_setup
 731   if (HAVE_builtin_setjmp_setup)
 732     emit_insn (gen_builtin_setjmp_setup (buf_addr));
 733 #endif
 734
 735   /* Tell optimize_save_area_alloca that extra work is going to
 736      need to go on during alloca.  */
 737   cfun->calls_setjmp = 1;
 738
 739   /* We have a nonlocal label.   */
 740   cfun->has_nonlocal_label = 1;
 741 }
 742
 743 /* Construct the trailing part of a __builtin_setjmp call.  This is
 744    also called directly by the SJLJ exception handling code.  */
 745
 746 void
 747 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
 748 {
 749   /* Clobber the FP when we get here, so we have to make sure it's
 750      marked as used by this function.  */
 751   emit_use (hard_frame_pointer_rtx);
 752
 753   /* Mark the static chain as clobbered here so life information
 754      doesn't get messed up for it.  */
 755   emit_clobber (static_chain_rtx);
 756
 757   /* Now put in the code to restore the frame pointer, and argument
 758      pointer, if needed.  */
 759 #ifdef HAVE_nonlocal_goto
 760   if (! HAVE_nonlocal_goto)
 761 #endif
 762     {
 763       emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 764       /* This might change the hard frame pointer in ways that aren't
 765          apparent to early optimization passes, so force a clobber.  */
 766       emit_clobber (hard_frame_pointer_rtx);
 767     }
 768
 769 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 770   if (fixed_regs[ARG_POINTER_REGNUM])
 771     {
 772 #ifdef ELIMINABLE_REGS
 773       size_t i;
 774       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 775
 776       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 777         if (elim_regs[i].from == ARG_POINTER_REGNUM
 778             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 779           break;
 780
 781       if (i == ARRAY_SIZE (elim_regs))
 782 #endif
 783         {
 784           /* Now restore our arg pointer from the address at which it
 785              was saved in our stack frame.  */
 786           emit_move_insn (crtl->args.internal_arg_pointer,
 787                           copy_to_reg (get_arg_pointer_save_area ()));
 788         }
 789     }
 790 #endif
 791
 792 #ifdef HAVE_builtin_setjmp_receiver
 793   if (HAVE_builtin_setjmp_receiver)
 794     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
 795   else
 796 #endif
 797 #ifdef HAVE_nonlocal_goto_receiver
 798     if (HAVE_nonlocal_goto_receiver)
 799       emit_insn (gen_nonlocal_goto_receiver ());
 800     else
 801 #endif
 802       { /* Nothing */ }
 803
 804   /* We must not allow the code we just generated to be reordered by
 805      scheduling.  Specifically, the update of the frame pointer must
 806      happen immediately, not later.  */
 807   emit_insn (gen_blockage ());
 808 }
 809
 810 /* __builtin_longjmp is passed a pointer to an array of five words (not
 811    all will be used on all machines).  It operates similarly to the C
 812    library function of the same name, but is more efficient.  Much of
 813    the code below is copied from the handling of non-local gotos.  */
 814
 815 static void
 816 expand_builtin_longjmp (rtx buf_addr, rtx value)
 817 {
 818   rtx fp, lab, stack, insn, last;
 819   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 820
 821   /* DRAP is needed for stack realign if longjmp is expanded to current
 822      function  */
 823   if (SUPPORTS_STACK_ALIGNMENT)
 824     crtl->need_drap = true;
 825
 826   if (setjmp_alias_set == -1)
 827     setjmp_alias_set = new_alias_set ();
 828
 829   buf_addr = convert_memory_address (Pmode, buf_addr);
 830
 831   buf_addr = force_reg (Pmode, buf_addr);
 832
 833   /* We used to store value in static_chain_rtx, but that fails if pointers
 834      are smaller than integers.  We instead require that the user must pass
 835      a second argument of 1, because that is what builtin_setjmp will
 836      return.  This also makes EH slightly more efficient, since we are no
 837      longer copying around a value that we don't care about.  */
 838   gcc_assert (value == const1_rtx);
 839
 840   last = get_last_insn ();
 841 #ifdef HAVE_builtin_longjmp
 842   if (HAVE_builtin_longjmp)
 843     emit_insn (gen_builtin_longjmp (buf_addr));
 844   else
 845 #endif
 846     {
 847       fp = gen_rtx_MEM (Pmode, buf_addr);
 848       lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
 849                                                GET_MODE_SIZE (Pmode)));
 850
 851       stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
 852                                                    2 * GET_MODE_SIZE (Pmode)));
 853       set_mem_alias_set (fp, setjmp_alias_set);
 854       set_mem_alias_set (lab, setjmp_alias_set);
 855       set_mem_alias_set (stack, setjmp_alias_set);
 856
 857       /* Pick up FP, label, and SP from the block and jump.  This code is
 858          from expand_goto in stmt.c; see there for detailed comments.  */
 859 #ifdef HAVE_nonlocal_goto
 860       if (HAVE_nonlocal_goto)
 861         /* We have to pass a value to the nonlocal_goto pattern that will
 862            get copied into the static_chain pointer, but it does not matter
 863            what that value is, because builtin_setjmp does not use it.  */
 864         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
 865       else
 866 #endif
 867         {
 868           lab = copy_to_reg (lab);
 869
 870           emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 871           emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 872
 873           emit_move_insn (hard_frame_pointer_rtx, fp);
 874           emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
 875
 876           emit_use (hard_frame_pointer_rtx);
 877           emit_use (stack_pointer_rtx);
 878           emit_indirect_jump (lab);
 879         }
 880     }
 881
 882   /* Search backwards and mark the jump insn as a non-local goto.
 883      Note that this precludes the use of __builtin_longjmp to a
 884      __builtin_setjmp target in the same function.  However, we've
 885      already cautioned the user that these functions are for
 886      internal exception handling use only.  */
 887   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 888     {
 889       gcc_assert (insn != last);
 890
 891       if (JUMP_P (insn))
 892         {
 893           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
 894           break;
 895         }
 896       else if (CALL_P (insn))
 897         break;
 898     }
 899 }
 900
 901 /* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
 902    and the address of the save area.  */
 903
 904 static rtx
 905 expand_builtin_nonlocal_goto (tree exp)
 906 {
 907   tree t_label, t_save_area;
 908   rtx r_label, r_save_area, r_fp, r_sp, insn;
 909
 910   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
 911     return NULL_RTX;
 912
 913   t_label = CALL_EXPR_ARG (exp, 0);
 914   t_save_area = CALL_EXPR_ARG (exp, 1);
 915
 916   r_label = expand_normal (t_label);
 917   r_label = convert_memory_address (Pmode, r_label);
 918   r_save_area = expand_normal (t_save_area);
 919   r_save_area = convert_memory_address (Pmode, r_save_area);
 920   /* Copy the address of the save location to a register just in case it was based
 921     on the frame pointer.   */
 922   r_save_area = copy_to_reg (r_save_area);
 923   r_fp = gen_rtx_MEM (Pmode, r_save_area);
 924   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
 925                       plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
 926
 927   crtl->has_nonlocal_goto = 1;
 928
 929 #ifdef HAVE_nonlocal_goto
 930   /* ??? We no longer need to pass the static chain value, afaik.  */
 931   if (HAVE_nonlocal_goto)
 932     emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
 933   else
 934 #endif
 935     {
 936       r_label = copy_to_reg (r_label);
 937
 938       emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 939       emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 940
 941       /* Restore frame pointer for containing function.
 942          This sets the actual hard register used for the frame pointer
 943          to the location of the function's incoming static chain info.
 944          The non-local goto handler will then adjust it to contain the
 945          proper value and reload the argument pointer, if needed.  */
 946       emit_move_insn (hard_frame_pointer_rtx, r_fp);
 947       emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
 948
 949       /* USE of hard_frame_pointer_rtx added for consistency;
 950          not clear if really needed.  */
 951       emit_use (hard_frame_pointer_rtx);
 952       emit_use (stack_pointer_rtx);
 953
 954       /* If the architecture is using a GP register, we must
 955          conservatively assume that the target function makes use of it.
 956          The prologue of functions with nonlocal gotos must therefore
 957          initialize the GP register to the appropriate value, and we
 958          must then make sure that this value is live at the point
 959          of the jump.  (Note that this doesn't necessarily apply
 960          to targets with a nonlocal_goto pattern; they are free
 961          to implement it in their own way.  Note also that this is
 962          a no-op if the GP register is a global invariant.)  */
 963       if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
 964           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
 965         emit_use (pic_offset_table_rtx);
 966
 967       emit_indirect_jump (r_label);
 968     }
 969
 970   /* Search backwards to the jump insn and mark it as a
 971      non-local goto.  */
 972   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 973     {
 974       if (JUMP_P (insn))
 975         {
 976           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
 977           break;
 978         }
 979       else if (CALL_P (insn))
 980         break;
 981     }
 982
 983   return const0_rtx;
 984 }
 985
 986 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
 987    (not all will be used on all machines) that was passed to __builtin_setjmp.
 988    It updates the stack pointer in that block to correspond to the current
 989    stack pointer.  */
 990
 991 static void
 992 expand_builtin_update_setjmp_buf (rtx buf_addr)
 993 {
 994   enum machine_mode sa_mode = Pmode;
 995   rtx stack_save;
 996
 997
 998 #ifdef HAVE_save_stack_nonlocal
 999   if (HAVE_save_stack_nonlocal)
1000     sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
1001 #endif
1002 #ifdef STACK_SAVEAREA_MODE
1003   sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1004 #endif
1005
1006   stack_save
1007     = gen_rtx_MEM (sa_mode,
1008                    memory_address
1009                    (sa_mode,
1010                     plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1011
1012 #ifdef HAVE_setjmp
1013   if (HAVE_setjmp)
1014     emit_insn (gen_setjmp ());
1015 #endif
1016
1017   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
1018 }
1019
1020 /* Expand a call to __builtin_prefetch.  For a target that does not support
1021    data prefetch, evaluate the memory address argument in case it has side
1022    effects.  */
1023
1024 static void
1025 expand_builtin_prefetch (tree exp)
1026 {
1027   tree arg0, arg1, arg2;
1028   int nargs;
1029   rtx op0, op1, op2;
1030
1031   if (!validate_arglist (exp, POINTER_TYPE, 0))
1032     return;
1033
1034   arg0 = CALL_EXPR_ARG (exp, 0);
1035
1036   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1037      zero (read) and argument 2 (locality) defaults to 3 (high degree of
1038      locality).  */
1039   nargs = call_expr_nargs (exp);
1040   if (nargs > 1)
1041     arg1 = CALL_EXPR_ARG (exp, 1);
1042   else
1043     arg1 = integer_zero_node;
1044   if (nargs > 2)
1045     arg2 = CALL_EXPR_ARG (exp, 2);
1046   else
1047     arg2 = build_int_cst (NULL_TREE, 3);
1048
1049   /* Argument 0 is an address.  */
1050   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1051
1052   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
1053   if (TREE_CODE (arg1) != INTEGER_CST)
1054     {
1055       error ("second argument to %<__builtin_prefetch%> must be a constant");
1056       arg1 = integer_zero_node;
1057     }
1058   op1 = expand_normal (arg1);
1059   /* Argument 1 must be either zero or one.  */
1060   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1061     {
1062       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1063                " using zero");
1064       op1 = const0_rtx;
1065     }
1066
1067   /* Argument 2 (locality) must be a compile-time constant int.  */
1068   if (TREE_CODE (arg2) != INTEGER_CST)
1069     {
1070       error ("third argument to %<__builtin_prefetch%> must be a constant");
1071       arg2 = integer_zero_node;
1072     }
1073   op2 = expand_normal (arg2);
1074   /* Argument 2 must be 0, 1, 2, or 3.  */
1075   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1076     {
1077       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1078       op2 = const0_rtx;
1079     }
1080
1081 #ifdef HAVE_prefetch
1082   if (HAVE_prefetch)
1083     {
1084       if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
1085              (op0,
1086               insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1087           || (GET_MODE (op0) != Pmode))
1088         {
1089           op0 = convert_memory_address (Pmode, op0);
1090           op0 = force_reg (Pmode, op0);
1091         }
1092       emit_insn (gen_prefetch (op0, op1, op2));
1093     }
1094 #endif
1095
1096   /* Don't do anything with direct references to volatile memory, but
1097      generate code to handle other side effects.  */
1098   if (!MEM_P (op0) && side_effects_p (op0))
1099     emit_insn (op0);
1100 }
1101
1102 /* Get a MEM rtx for expression EXP which is the address of an operand
1103    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1104    the maximum length of the block of memory that might be accessed or
1105    NULL if unknown.  */
1106
1107 static rtx
1108 get_memory_rtx (tree exp, tree len)
1109 {
1110   tree orig_exp = exp;
1111   rtx addr, mem;
1112   HOST_WIDE_INT off;
1113
1114   /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1115      from its expression, for expr->a.b only <variable>.a.b is recorded.  */
1116   if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1117     exp = TREE_OPERAND (exp, 0);
1118
1119   addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1120   mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1121
1122   /* Get an expression we can use to find the attributes to assign to MEM.
1123      If it is an ADDR_EXPR, use the operand.  Otherwise, dereference it if
1124      we can.  First remove any nops.  */
1125   while (CONVERT_EXPR_P (exp)
1126          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1127     exp = TREE_OPERAND (exp, 0);
1128
1129   off = 0;
1130   if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1131       && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1132       && host_integerp (TREE_OPERAND (exp, 1), 0)
1133       && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1134     exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1135   else if (TREE_CODE (exp) == ADDR_EXPR)
1136     exp = TREE_OPERAND (exp, 0);
1137   else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1138     exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1139   else
1140     exp = NULL;
1141
1142   /* Honor attributes derived from exp, except for the alias set
1143      (as builtin stringops may alias with anything) and the size
1144      (as stringops may access multiple array elements).  */
1145   if (exp)
1146     {
1147       set_mem_attributes (mem, exp, 0);
1148
1149       if (off)
1150         mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1151
1152       /* Allow the string and memory builtins to overflow from one
1153          field into another, see http://gcc.gnu.org/PR23561.
1154          Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1155          memory accessed by the string or memory builtin will fit
1156          within the field.  */
1157       if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1158         {
1159           tree mem_expr = MEM_EXPR (mem);
1160           HOST_WIDE_INT offset = -1, length = -1;
1161           tree inner = exp;
1162
1163           while (TREE_CODE (inner) == ARRAY_REF
1164                  || CONVERT_EXPR_P (inner)
1165                  || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1166                  || TREE_CODE (inner) == SAVE_EXPR)
1167             inner = TREE_OPERAND (inner, 0);
1168
1169           gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1170
1171           if (MEM_OFFSET (mem)
1172               && GET_CODE (MEM_OFFSET (mem)) == CONST_INT)
1173             offset = INTVAL (MEM_OFFSET (mem));
1174
1175           if (offset >= 0 && len && host_integerp (len, 0))
1176             length = tree_low_cst (len, 0);
1177
1178           while (TREE_CODE (inner) == COMPONENT_REF)
1179             {
1180               tree field = TREE_OPERAND (inner, 1);
1181               gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1182               gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1183
1184               /* Bitfields are generally not byte-addressable.  */
1185               gcc_assert (!DECL_BIT_FIELD (field)
1186                           || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1187                                % BITS_PER_UNIT) == 0
1188                               && host_integerp (DECL_SIZE (field), 0)
1189                               && (TREE_INT_CST_LOW (DECL_SIZE (field))
1190                                   % BITS_PER_UNIT) == 0));
1191
1192               /* If we can prove that the memory starting at XEXP (mem, 0) and
1193                  ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1194                  can keep the COMPONENT_REF in MEM_EXPR.  But be careful with
1195                  fields without DECL_SIZE_UNIT like flexible array members.  */
1196               if (length >= 0
1197                   && DECL_SIZE_UNIT (field)
1198                   && host_integerp (DECL_SIZE_UNIT (field), 0))
1199                 {
1200                   HOST_WIDE_INT size
1201                     = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1202                   if (offset <= size
1203                       && length <= size
1204                       && offset + length <= size)
1205                     break;
1206                 }
1207
1208               if (offset >= 0
1209                   && host_integerp (DECL_FIELD_OFFSET (field), 0))
1210                 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1211                           + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1212                             / BITS_PER_UNIT;
1213               else
1214                 {
1215                   offset = -1;
1216                   length = -1;
1217                 }
1218
1219               mem_expr = TREE_OPERAND (mem_expr, 0);
1220               inner = TREE_OPERAND (inner, 0);
1221             }
1222
1223           if (mem_expr == NULL)
1224             offset = -1;
1225           if (mem_expr != MEM_EXPR (mem))
1226             {
1227               set_mem_expr (mem, mem_expr);
1228               set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1229             }
1230         }
1231       set_mem_alias_set (mem, 0);
1232       set_mem_size (mem, NULL_RTX);
1233     }
1234
1235   return mem;
1236 }
1237 \f
1238 /* Built-in functions to perform an untyped call and return.  */
1239
1240 /* For each register that may be used for calling a function, this
1241    gives a mode used to copy the register's value.  VOIDmode indicates
1242    the register is not used for calling a function.  If the machine
1243    has register windows, this gives only the outbound registers.
1244    INCOMING_REGNO gives the corresponding inbound register.  */
1245 static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
1246
1247 /* For each register that may be used for returning values, this gives
1248    a mode used to copy the register's value.  VOIDmode indicates the
1249    register is not used for returning values.  If the machine has
1250    register windows, this gives only the outbound registers.
1251    INCOMING_REGNO gives the corresponding inbound register.  */
1252 static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
1253
1254 /* For each register that may be used for calling a function, this
1255    gives the offset of that register into the block returned by
1256    __builtin_apply_args.  0 indicates that the register is not
1257    used for calling a function.  */
1258 static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
1259
1260 /* Return the size required for the block returned by __builtin_apply_args,
1261    and initialize apply_args_mode.  */
1262
1263 static int
1264 apply_args_size (void)
1265 {
1266   static int size = -1;
1267   int align;
1268   unsigned int regno;
1269   enum machine_mode mode;
1270
1271   /* The values computed by this function never change.  */
1272   if (size < 0)
1273     {
1274       /* The first value is the incoming arg-pointer.  */
1275       size = GET_MODE_SIZE (Pmode);
1276
1277       /* The second value is the structure value address unless this is
1278          passed as an "invisible" first argument.  */
1279       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1280         size += GET_MODE_SIZE (Pmode);
1281
1282       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1283         if (FUNCTION_ARG_REGNO_P (regno))
1284           {
1285             mode = reg_raw_mode[regno];
1286
1287             gcc_assert (mode != VOIDmode);
1288
1289             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1290             if (size % align != 0)
1291               size = CEIL (size, align) * align;
1292             apply_args_reg_offset[regno] = size;
1293             size += GET_MODE_SIZE (mode);
1294             apply_args_mode[regno] = mode;
1295           }
1296         else
1297           {
1298             apply_args_mode[regno] = VOIDmode;
1299             apply_args_reg_offset[regno] = 0;
1300           }
1301     }
1302   return size;
1303 }
1304
1305 /* Return the size required for the block returned by __builtin_apply,
1306    and initialize apply_result_mode.  */
1307
1308 static int
1309 apply_result_size (void)
1310 {
1311   static int size = -1;
1312   int align, regno;
1313   enum machine_mode mode;
1314
1315   /* The values computed by this function never change.  */
1316   if (size < 0)
1317     {
1318       size = 0;
1319
1320       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1321         if (FUNCTION_VALUE_REGNO_P (regno))
1322           {
1323             mode = reg_raw_mode[regno];
1324
1325             gcc_assert (mode != VOIDmode);
1326
1327             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1328             if (size % align != 0)
1329               size = CEIL (size, align) * align;
1330             size += GET_MODE_SIZE (mode);
1331             apply_result_mode[regno] = mode;
1332           }
1333         else
1334           apply_result_mode[regno] = VOIDmode;
1335
1336       /* Allow targets that use untyped_call and untyped_return to override
1337          the size so that machine-specific information can be stored here.  */
1338 #ifdef APPLY_RESULT_SIZE
1339       size = APPLY_RESULT_SIZE;
1340 #endif
1341     }
1342   return size;
1343 }
1344
1345 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1346 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1347    the result block is used to save the values; otherwise it is used to
1348    restore the values.  */
1349
1350 static rtx
1351 result_vector (int savep, rtx result)
1352 {
1353   int regno, size, align, nelts;
1354   enum machine_mode mode;
1355   rtx reg, mem;
1356   rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1357
1358   size = nelts = 0;
1359   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1360     if ((mode = apply_result_mode[regno]) != VOIDmode)
1361       {
1362         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1363         if (size % align != 0)
1364           size = CEIL (size, align) * align;
1365         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1366         mem = adjust_address (result, mode, size);
1367         savevec[nelts++] = (savep
1368                             ? gen_rtx_SET (VOIDmode, mem, reg)
1369                             : gen_rtx_SET (VOIDmode, reg, mem));
1370         size += GET_MODE_SIZE (mode);
1371       }
1372   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1373 }
1374 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1375
1376 /* Save the state required to perform an untyped call with the same
1377    arguments as were passed to the current function.  */
1378
1379 static rtx
1380 expand_builtin_apply_args_1 (void)
1381 {
1382   rtx registers, tem;
1383   int size, align, regno;
1384   enum machine_mode mode;
1385   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1386
1387   /* Create a block where the arg-pointer, structure value address,
1388      and argument registers can be saved.  */
1389   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1390
1391   /* Walk past the arg-pointer and structure value address.  */
1392   size = GET_MODE_SIZE (Pmode);
1393   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1394     size += GET_MODE_SIZE (Pmode);
1395
1396   /* Save each register used in calling a function to the block.  */
1397   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1398     if ((mode = apply_args_mode[regno]) != VOIDmode)
1399       {
1400         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1401         if (size % align != 0)
1402           size = CEIL (size, align) * align;
1403
1404         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1405
1406         emit_move_insn (adjust_address (registers, mode, size), tem);
1407         size += GET_MODE_SIZE (mode);
1408       }
1409
1410   /* Save the arg pointer to the block.  */
1411   tem = copy_to_reg (crtl->args.internal_arg_pointer);
1412 #ifdef STACK_GROWS_DOWNWARD
1413   /* We need the pointer as the caller actually passed them to us, not
1414      as we might have pretended they were passed.  Make sure it's a valid
1415      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1416   tem
1417     = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1418                      NULL_RTX);
1419 #endif
1420   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1421
1422   size = GET_MODE_SIZE (Pmode);
1423
1424   /* Save the structure value address unless this is passed as an
1425      "invisible" first argument.  */
1426   if (struct_incoming_value)
1427     {
1428       emit_move_insn (adjust_address (registers, Pmode, size),
1429                       copy_to_reg (struct_incoming_value));
1430       size += GET_MODE_SIZE (Pmode);
1431     }
1432
1433   /* Return the address of the block.  */
1434   return copy_addr_to_reg (XEXP (registers, 0));
1435 }
1436
1437 /* __builtin_apply_args returns block of memory allocated on
1438    the stack into which is stored the arg pointer, structure
1439    value address, static chain, and all the registers that might
1440    possibly be used in performing a function call.  The code is
1441    moved to the start of the function so the incoming values are
1442    saved.  */
1443
1444 static rtx
1445 expand_builtin_apply_args (void)
1446 {
1447   /* Don't do __builtin_apply_args more than once in a function.
1448      Save the result of the first call and reuse it.  */
1449   if (apply_args_value != 0)
1450     return apply_args_value;
1451   {
1452     /* When this function is called, it means that registers must be
1453        saved on entry to this function.  So we migrate the
1454        call to the first insn of this function.  */
1455     rtx temp;
1456     rtx seq;
1457
1458     start_sequence ();
1459     temp = expand_builtin_apply_args_1 ();
1460     seq = get_insns ();
1461     end_sequence ();
1462
1463     apply_args_value = temp;
1464
1465     /* Put the insns after the NOTE that starts the function.
1466        If this is inside a start_sequence, make the outer-level insn
1467        chain current, so the code is placed at the start of the
1468        function.  If internal_arg_pointer is a non-virtual pseudo,
1469        it needs to be placed after the function that initializes
1470        that pseudo.  */
1471     push_topmost_sequence ();
1472     if (REG_P (crtl->args.internal_arg_pointer)
1473         && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1474       emit_insn_before (seq, parm_birth_insn);
1475     else
1476       emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1477     pop_topmost_sequence ();
1478     return temp;
1479   }
1480 }
1481
1482 /* Perform an untyped call and save the state required to perform an
1483    untyped return of whatever value was returned by the given function.  */
1484
1485 static rtx
1486 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1487 {
1488   int size, align, regno;
1489   enum machine_mode mode;
1490   rtx incoming_args, result, reg, dest, src, call_insn;
1491   rtx old_stack_level = 0;
1492   rtx call_fusage = 0;
1493   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1494
1495   arguments = convert_memory_address (Pmode, arguments);
1496
1497   /* Create a block where the return registers can be saved.  */
1498   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1499
1500   /* Fetch the arg pointer from the ARGUMENTS block.  */
1501   incoming_args = gen_reg_rtx (Pmode);
1502   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1503 #ifndef STACK_GROWS_DOWNWARD
1504   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1505                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1506 #endif
1507
1508   /* Push a new argument block and copy the arguments.  Do not allow
1509      the (potential) memcpy call below to interfere with our stack
1510      manipulations.  */
1511   do_pending_stack_adjust ();
1512   NO_DEFER_POP;
1513
1514   /* Save the stack with nonlocal if available.  */
1515 #ifdef HAVE_save_stack_nonlocal
1516   if (HAVE_save_stack_nonlocal)
1517     emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1518   else
1519 #endif
1520     emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1521
1522   /* Allocate a block of memory onto the stack and copy the memory
1523      arguments to the outgoing arguments address.  */
1524   allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1525
1526   /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1527      may have already set current_function_calls_alloca to true.
1528      current_function_calls_alloca won't be set if argsize is zero,
1529      so we have to guarantee need_drap is true here.  */
1530   if (SUPPORTS_STACK_ALIGNMENT)
1531     crtl->need_drap = true;
1532
1533   dest = virtual_outgoing_args_rtx;
1534 #ifndef STACK_GROWS_DOWNWARD
1535   if (GET_CODE (argsize) == CONST_INT)
1536     dest = plus_constant (dest, -INTVAL (argsize));
1537   else
1538     dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1539 #endif
1540   dest = gen_rtx_MEM (BLKmode, dest);
1541   set_mem_align (dest, PARM_BOUNDARY);
1542   src = gen_rtx_MEM (BLKmode, incoming_args);
1543   set_mem_align (src, PARM_BOUNDARY);
1544   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1545
1546   /* Refer to the argument block.  */
1547   apply_args_size ();
1548   arguments = gen_rtx_MEM (BLKmode, arguments);
1549   set_mem_align (arguments, PARM_BOUNDARY);
1550
1551   /* Walk past the arg-pointer and structure value address.  */
1552   size = GET_MODE_SIZE (Pmode);
1553   if (struct_value)
1554     size += GET_MODE_SIZE (Pmode);
1555
1556   /* Restore each of the registers previously saved.  Make USE insns
1557      for each of these registers for use in making the call.  */
1558   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1559     if ((mode = apply_args_mode[regno]) != VOIDmode)
1560       {
1561         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1562         if (size % align != 0)
1563           size = CEIL (size, align) * align;
1564         reg = gen_rtx_REG (mode, regno);
1565         emit_move_insn (reg, adjust_address (arguments, mode, size));
1566         use_reg (&call_fusage, reg);
1567         size += GET_MODE_SIZE (mode);
1568       }
1569
1570   /* Restore the structure value address unless this is passed as an
1571      "invisible" first argument.  */
1572   size = GET_MODE_SIZE (Pmode);
1573   if (struct_value)
1574     {
1575       rtx value = gen_reg_rtx (Pmode);
1576       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1577       emit_move_insn (struct_value, value);
1578       if (REG_P (struct_value))
1579         use_reg (&call_fusage, struct_value);
1580       size += GET_MODE_SIZE (Pmode);
1581     }
1582
1583   /* All arguments and registers used for the call are set up by now!  */
1584   function = prepare_call_address (function, NULL, &call_fusage, 0, 0);
1585
1586   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1587      and we don't want to load it into a register as an optimization,
1588      because prepare_call_address already did it if it should be done.  */
1589   if (GET_CODE (function) != SYMBOL_REF)
1590     function = memory_address (FUNCTION_MODE, function);
1591
1592   /* Generate the actual call instruction and save the return value.  */
1593 #ifdef HAVE_untyped_call
1594   if (HAVE_untyped_call)
1595     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1596                                       result, result_vector (1, result)));
1597   else
1598 #endif
1599 #ifdef HAVE_call_value
1600   if (HAVE_call_value)
1601     {
1602       rtx valreg = 0;
1603
1604       /* Locate the unique return register.  It is not possible to
1605          express a call that sets more than one return register using
1606          call_value; use untyped_call for that.  In fact, untyped_call
1607          only needs to save the return registers in the given block.  */
1608       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1609         if ((mode = apply_result_mode[regno]) != VOIDmode)
1610           {
1611             gcc_assert (!valreg); /* HAVE_untyped_call required.  */
1612
1613             valreg = gen_rtx_REG (mode, regno);
1614           }
1615
1616       emit_call_insn (GEN_CALL_VALUE (valreg,
1617                                       gen_rtx_MEM (FUNCTION_MODE, function),
1618                                       const0_rtx, NULL_RTX, const0_rtx));
1619
1620       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1621     }
1622   else
1623 #endif
1624     gcc_unreachable ();
1625
1626   /* Find the CALL insn we just emitted, and attach the register usage
1627      information.  */
1628   call_insn = last_call_insn ();
1629   add_function_usage_to (call_insn, call_fusage);
1630
1631   /* Restore the stack.  */
1632 #ifdef HAVE_save_stack_nonlocal
1633   if (HAVE_save_stack_nonlocal)
1634     emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1635   else
1636 #endif
1637     emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1638
1639   OK_DEFER_POP;
1640
1641   /* Return the address of the result block.  */
1642   result = copy_addr_to_reg (XEXP (result, 0));
1643   return convert_memory_address (ptr_mode, result);
1644 }
1645
1646 /* Perform an untyped return.  */
1647
1648 static void
1649 expand_builtin_return (rtx result)
1650 {
1651   int size, align, regno;
1652   enum machine_mode mode;
1653   rtx reg;
1654   rtx call_fusage = 0;
1655
1656   result = convert_memory_address (Pmode, result);
1657
1658   apply_result_size ();
1659   result = gen_rtx_MEM (BLKmode, result);
1660
1661 #ifdef HAVE_untyped_return
1662   if (HAVE_untyped_return)
1663     {
1664       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1665       emit_barrier ();
1666       return;
1667     }
1668 #endif
1669
1670   /* Restore the return value and note that each value is used.  */
1671   size = 0;
1672   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1673     if ((mode = apply_result_mode[regno]) != VOIDmode)
1674       {
1675         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1676         if (size % align != 0)
1677           size = CEIL (size, align) * align;
1678         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1679         emit_move_insn (reg, adjust_address (result, mode, size));
1680
1681         push_to_sequence (call_fusage);
1682         emit_use (reg);
1683         call_fusage = get_insns ();
1684         end_sequence ();
1685         size += GET_MODE_SIZE (mode);
1686       }
1687
1688   /* Put the USE insns before the return.  */
1689   emit_insn (call_fusage);
1690
1691   /* Return whatever values was restored by jumping directly to the end
1692      of the function.  */
1693   expand_naked_return ();
1694 }
1695
1696 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1697
1698 static enum type_class
1699 type_to_class (tree type)
1700 {
1701   switch (TREE_CODE (type))
1702     {
1703     case VOID_TYPE:        return void_type_class;
1704     case INTEGER_TYPE:     return integer_type_class;
1705     case ENUMERAL_TYPE:    return enumeral_type_class;
1706     case BOOLEAN_TYPE:     return boolean_type_class;
1707     case POINTER_TYPE:     return pointer_type_class;
1708     case REFERENCE_TYPE:   return reference_type_class;
1709     case OFFSET_TYPE:      return offset_type_class;
1710     case REAL_TYPE:        return real_type_class;
1711     case COMPLEX_TYPE:     return complex_type_class;
1712     case FUNCTION_TYPE:    return function_type_class;
1713     case METHOD_TYPE:      return method_type_class;
1714     case RECORD_TYPE:      return record_type_class;
1715     case UNION_TYPE:
1716     case QUAL_UNION_TYPE:  return union_type_class;
1717     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1718                                    ? string_type_class : array_type_class);
1719     case LANG_TYPE:        return lang_type_class;
1720     default:               return no_type_class;
1721     }
1722 }
1723
1724 /* Expand a call EXP to __builtin_classify_type.  */
1725
1726 static rtx
1727 expand_builtin_classify_type (tree exp)
1728 {
1729   if (call_expr_nargs (exp))
1730     return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1731   return GEN_INT (no_type_class);
1732 }
1733
1734 /* This helper macro, meant to be used in mathfn_built_in below,
1735    determines which among a set of three builtin math functions is
1736    appropriate for a given type mode.  The `F' and `L' cases are
1737    automatically generated from the `double' case.  */
1738 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1739   case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1740   fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1741   fcodel = BUILT_IN_MATHFN##L ; break;
1742 /* Similar to above, but appends _R after any F/L suffix.  */
1743 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1744   case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1745   fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1746   fcodel = BUILT_IN_MATHFN##L_R ; break;
1747
1748 /* Return mathematic function equivalent to FN but operating directly
1749    on TYPE, if available.  If IMPLICIT is true find the function in
1750    implicit_built_in_decls[], otherwise use built_in_decls[].  If we
1751    can't do the conversion, return zero.  */
1752
1753 static tree
1754 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit)
1755 {
1756   tree const *const fn_arr
1757     = implicit ? implicit_built_in_decls : built_in_decls;
1758   enum built_in_function fcode, fcodef, fcodel;
1759
1760   switch (fn)
1761     {
1762       CASE_MATHFN (BUILT_IN_ACOS)
1763       CASE_MATHFN (BUILT_IN_ACOSH)
1764       CASE_MATHFN (BUILT_IN_ASIN)
1765       CASE_MATHFN (BUILT_IN_ASINH)
1766       CASE_MATHFN (BUILT_IN_ATAN)
1767       CASE_MATHFN (BUILT_IN_ATAN2)
1768       CASE_MATHFN (BUILT_IN_ATANH)
1769       CASE_MATHFN (BUILT_IN_CBRT)
1770       CASE_MATHFN (BUILT_IN_CEIL)
1771       CASE_MATHFN (BUILT_IN_CEXPI)
1772       CASE_MATHFN (BUILT_IN_COPYSIGN)
1773       CASE_MATHFN (BUILT_IN_COS)
1774       CASE_MATHFN (BUILT_IN_COSH)
1775       CASE_MATHFN (BUILT_IN_DREM)
1776       CASE_MATHFN (BUILT_IN_ERF)
1777       CASE_MATHFN (BUILT_IN_ERFC)
1778       CASE_MATHFN (BUILT_IN_EXP)
1779       CASE_MATHFN (BUILT_IN_EXP10)
1780       CASE_MATHFN (BUILT_IN_EXP2)
1781       CASE_MATHFN (BUILT_IN_EXPM1)
1782       CASE_MATHFN (BUILT_IN_FABS)
1783       CASE_MATHFN (BUILT_IN_FDIM)
1784       CASE_MATHFN (BUILT_IN_FLOOR)
1785       CASE_MATHFN (BUILT_IN_FMA)
1786       CASE_MATHFN (BUILT_IN_FMAX)
1787       CASE_MATHFN (BUILT_IN_FMIN)
1788       CASE_MATHFN (BUILT_IN_FMOD)
1789       CASE_MATHFN (BUILT_IN_FREXP)
1790       CASE_MATHFN (BUILT_IN_GAMMA)
1791       CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1792       CASE_MATHFN (BUILT_IN_HUGE_VAL)
1793       CASE_MATHFN (BUILT_IN_HYPOT)
1794       CASE_MATHFN (BUILT_IN_ILOGB)
1795       CASE_MATHFN (BUILT_IN_INF)
1796       CASE_MATHFN (BUILT_IN_ISINF)
1797       CASE_MATHFN (BUILT_IN_J0)
1798       CASE_MATHFN (BUILT_IN_J1)
1799       CASE_MATHFN (BUILT_IN_JN)
1800       CASE_MATHFN (BUILT_IN_LCEIL)
1801       CASE_MATHFN (BUILT_IN_LDEXP)
1802       CASE_MATHFN (BUILT_IN_LFLOOR)
1803       CASE_MATHFN (BUILT_IN_LGAMMA)
1804       CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1805       CASE_MATHFN (BUILT_IN_LLCEIL)
1806       CASE_MATHFN (BUILT_IN_LLFLOOR)
1807       CASE_MATHFN (BUILT_IN_LLRINT)
1808       CASE_MATHFN (BUILT_IN_LLROUND)
1809       CASE_MATHFN (BUILT_IN_LOG)
1810       CASE_MATHFN (BUILT_IN_LOG10)
1811       CASE_MATHFN (BUILT_IN_LOG1P)
1812       CASE_MATHFN (BUILT_IN_LOG2)
1813       CASE_MATHFN (BUILT_IN_LOGB)
1814       CASE_MATHFN (BUILT_IN_LRINT)
1815       CASE_MATHFN (BUILT_IN_LROUND)
1816       CASE_MATHFN (BUILT_IN_MODF)
1817       CASE_MATHFN (BUILT_IN_NAN)
1818       CASE_MATHFN (BUILT_IN_NANS)
1819       CASE_MATHFN (BUILT_IN_NEARBYINT)
1820       CASE_MATHFN (BUILT_IN_NEXTAFTER)
1821       CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1822       CASE_MATHFN (BUILT_IN_POW)
1823       CASE_MATHFN (BUILT_IN_POWI)
1824       CASE_MATHFN (BUILT_IN_POW10)
1825       CASE_MATHFN (BUILT_IN_REMAINDER)
1826       CASE_MATHFN (BUILT_IN_REMQUO)
1827       CASE_MATHFN (BUILT_IN_RINT)
1828       CASE_MATHFN (BUILT_IN_ROUND)
1829       CASE_MATHFN (BUILT_IN_SCALB)
1830       CASE_MATHFN (BUILT_IN_SCALBLN)
1831       CASE_MATHFN (BUILT_IN_SCALBN)
1832       CASE_MATHFN (BUILT_IN_SIGNBIT)
1833       CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1834       CASE_MATHFN (BUILT_IN_SIN)
1835       CASE_MATHFN (BUILT_IN_SINCOS)
1836       CASE_MATHFN (BUILT_IN_SINH)
1837       CASE_MATHFN (BUILT_IN_SQRT)
1838       CASE_MATHFN (BUILT_IN_TAN)
1839       CASE_MATHFN (BUILT_IN_TANH)
1840       CASE_MATHFN (BUILT_IN_TGAMMA)
1841       CASE_MATHFN (BUILT_IN_TRUNC)
1842       CASE_MATHFN (BUILT_IN_Y0)
1843       CASE_MATHFN (BUILT_IN_Y1)
1844       CASE_MATHFN (BUILT_IN_YN)
1845
1846       default:
1847         return NULL_TREE;
1848       }
1849
1850   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1851     return fn_arr[fcode];
1852   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1853     return fn_arr[fcodef];
1854   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1855     return fn_arr[fcodel];
1856   else
1857     return NULL_TREE;
1858 }
1859
1860 /* Like mathfn_built_in_1(), but always use the implicit array.  */
1861
1862 tree
1863 mathfn_built_in (tree type, enum built_in_function fn)
1864 {
1865   return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1866 }
1867
1868 /* If errno must be maintained, expand the RTL to check if the result,
1869    TARGET, of a built-in function call, EXP, is NaN, and if so set
1870    errno to EDOM.  */
1871
1872 static void
1873 expand_errno_check (tree exp, rtx target)
1874 {
1875   rtx lab = gen_label_rtx ();
1876
1877   /* Test the result; if it is NaN, set errno=EDOM because
1878      the argument was not in the domain.  */
1879   emit_cmp_and_jump_insns (target, target, EQ, 0, GET_MODE (target),
1880                            0, lab);
1881
1882 #ifdef TARGET_EDOM
1883   /* If this built-in doesn't throw an exception, set errno directly.  */
1884   if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1885     {
1886 #ifdef GEN_ERRNO_RTX
1887       rtx errno_rtx = GEN_ERRNO_RTX;
1888 #else
1889       rtx errno_rtx
1890           = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1891 #endif
1892       emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1893       emit_label (lab);
1894       return;
1895     }
1896 #endif
1897
1898   /* Make sure the library call isn't expanded as a tail call.  */
1899   CALL_EXPR_TAILCALL (exp) = 0;
1900
1901   /* We can't set errno=EDOM directly; let the library call do it.
1902      Pop the arguments right away in case the call gets deleted.  */
1903   NO_DEFER_POP;
1904   expand_call (exp, target, 0);
1905   OK_DEFER_POP;
1906   emit_label (lab);
1907 }
1908
1909 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1910    Return NULL_RTX if a normal call should be emitted rather than expanding
1911    the function in-line.  EXP is the expression that is a call to the builtin
1912    function; if convenient, the result should be placed in TARGET.
1913    SUBTARGET may be used as the target for computing one of EXP's operands.  */
1914
1915 static rtx
1916 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1917 {
1918   optab builtin_optab;
1919   rtx op0, insns, before_call;
1920   tree fndecl = get_callee_fndecl (exp);
1921   enum machine_mode mode;
1922   bool errno_set = false;
1923   tree arg;
1924
1925   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1926     return NULL_RTX;
1927
1928   arg = CALL_EXPR_ARG (exp, 0);
1929
1930   switch (DECL_FUNCTION_CODE (fndecl))
1931     {
1932     CASE_FLT_FN (BUILT_IN_SQRT):
1933       errno_set = ! tree_expr_nonnegative_p (arg);
1934       builtin_optab = sqrt_optab;
1935       break;
1936     CASE_FLT_FN (BUILT_IN_EXP):
1937       errno_set = true; builtin_optab = exp_optab; break;
1938     CASE_FLT_FN (BUILT_IN_EXP10):
1939     CASE_FLT_FN (BUILT_IN_POW10):
1940       errno_set = true; builtin_optab = exp10_optab; break;
1941     CASE_FLT_FN (BUILT_IN_EXP2):
1942       errno_set = true; builtin_optab = exp2_optab; break;
1943     CASE_FLT_FN (BUILT_IN_EXPM1):
1944       errno_set = true; builtin_optab = expm1_optab; break;
1945     CASE_FLT_FN (BUILT_IN_LOGB):
1946       errno_set = true; builtin_optab = logb_optab; break;
1947     CASE_FLT_FN (BUILT_IN_LOG):
1948       errno_set = true; builtin_optab = log_optab; break;
1949     CASE_FLT_FN (BUILT_IN_LOG10):
1950       errno_set = true; builtin_optab = log10_optab; break;
1951     CASE_FLT_FN (BUILT_IN_LOG2):
1952       errno_set = true; builtin_optab = log2_optab; break;
1953     CASE_FLT_FN (BUILT_IN_LOG1P):
1954       errno_set = true; builtin_optab = log1p_optab; break;
1955     CASE_FLT_FN (BUILT_IN_ASIN):
1956       builtin_optab = asin_optab; break;
1957     CASE_FLT_FN (BUILT_IN_ACOS):
1958       builtin_optab = acos_optab; break;
1959     CASE_FLT_FN (BUILT_IN_TAN):
1960       builtin_optab = tan_optab; break;
1961     CASE_FLT_FN (BUILT_IN_ATAN):
1962       builtin_optab = atan_optab; break;
1963     CASE_FLT_FN (BUILT_IN_FLOOR):
1964       builtin_optab = floor_optab; break;
1965     CASE_FLT_FN (BUILT_IN_CEIL):
1966       builtin_optab = ceil_optab; break;
1967     CASE_FLT_FN (BUILT_IN_TRUNC):
1968       builtin_optab = btrunc_optab; break;
1969     CASE_FLT_FN (BUILT_IN_ROUND):
1970       builtin_optab = round_optab; break;
1971     CASE_FLT_FN (BUILT_IN_NEARBYINT):
1972       builtin_optab = nearbyint_optab;
1973       if (flag_trapping_math)
1974         break;
1975       /* Else fallthrough and expand as rint.  */
1976     CASE_FLT_FN (BUILT_IN_RINT):
1977       builtin_optab = rint_optab; break;
1978     default:
1979       gcc_unreachable ();
1980     }
1981
1982   /* Make a suitable register to place result in.  */
1983   mode = TYPE_MODE (TREE_TYPE (exp));
1984
1985   if (! flag_errno_math || ! HONOR_NANS (mode))
1986     errno_set = false;
1987
1988   /* Before working hard, check whether the instruction is available.  */
1989   if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
1990     {
1991       target = gen_reg_rtx (mode);
1992
1993       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
1994          need to expand the argument again.  This way, we will not perform
1995          side-effects more the once.  */
1996       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
1997
1998       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
1999
2000       start_sequence ();
2001
2002       /* Compute into TARGET.
2003          Set TARGET to wherever the result comes back.  */
2004       target = expand_unop (mode, builtin_optab, op0, target, 0);
2005
2006       if (target != 0)
2007         {
2008           if (errno_set)
2009             expand_errno_check (exp, target);
2010
2011           /* Output the entire sequence.  */
2012           insns = get_insns ();
2013           end_sequence ();
2014           emit_insn (insns);
2015           return target;
2016         }
2017
2018       /* If we were unable to expand via the builtin, stop the sequence
2019          (without outputting the insns) and call to the library function
2020          with the stabilized argument list.  */
2021       end_sequence ();
2022     }
2023
2024   before_call = get_last_insn ();
2025
2026   return expand_call (exp, target, target == const0_rtx);
2027 }
2028
2029 /* Expand a call to the builtin binary math functions (pow and atan2).
2030    Return NULL_RTX if a normal call should be emitted rather than expanding the
2031    function in-line.  EXP is the expression that is a call to the builtin
2032    function; if convenient, the result should be placed in TARGET.
2033    SUBTARGET may be used as the target for computing one of EXP's
2034    operands.  */
2035
2036 static rtx
2037 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2038 {
2039   optab builtin_optab;
2040   rtx op0, op1, insns;
2041   int op1_type = REAL_TYPE;
2042   tree fndecl = get_callee_fndecl (exp);
2043   tree arg0, arg1;
2044   enum machine_mode mode;
2045   bool errno_set = true;
2046
2047   switch (DECL_FUNCTION_CODE (fndecl))
2048     {
2049     CASE_FLT_FN (BUILT_IN_SCALBN):
2050     CASE_FLT_FN (BUILT_IN_SCALBLN):
2051     CASE_FLT_FN (BUILT_IN_LDEXP):
2052       op1_type = INTEGER_TYPE;
2053     default:
2054       break;
2055     }
2056
2057   if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2058     return NULL_RTX;
2059
2060   arg0 = CALL_EXPR_ARG (exp, 0);
2061   arg1 = CALL_EXPR_ARG (exp, 1);
2062
2063   switch (DECL_FUNCTION_CODE (fndecl))
2064     {
2065     CASE_FLT_FN (BUILT_IN_POW):
2066       builtin_optab = pow_optab; break;
2067     CASE_FLT_FN (BUILT_IN_ATAN2):
2068       builtin_optab = atan2_optab; break;
2069     CASE_FLT_FN (BUILT_IN_SCALB):
2070       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2071         return 0;
2072       builtin_optab = scalb_optab; break;
2073     CASE_FLT_FN (BUILT_IN_SCALBN):
2074     CASE_FLT_FN (BUILT_IN_SCALBLN):
2075       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2076         return 0;
2077     /* Fall through... */
2078     CASE_FLT_FN (BUILT_IN_LDEXP):
2079       builtin_optab = ldexp_optab; break;
2080     CASE_FLT_FN (BUILT_IN_FMOD):
2081       builtin_optab = fmod_optab; break;
2082     CASE_FLT_FN (BUILT_IN_REMAINDER):
2083     CASE_FLT_FN (BUILT_IN_DREM):
2084       builtin_optab = remainder_optab; break;
2085     default:
2086       gcc_unreachable ();
2087     }
2088
2089   /* Make a suitable register to place result in.  */
2090   mode = TYPE_MODE (TREE_TYPE (exp));
2091
2092   /* Before working hard, check whether the instruction is available.  */
2093   if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2094     return NULL_RTX;
2095
2096   target = gen_reg_rtx (mode);
2097
2098   if (! flag_errno_math || ! HONOR_NANS (mode))
2099     errno_set = false;
2100
2101   /* Always stabilize the argument list.  */
2102   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2103   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2104
2105   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2106   op1 = expand_normal (arg1);
2107
2108   start_sequence ();
2109
2110   /* Compute into TARGET.
2111      Set TARGET to wherever the result comes back.  */
2112   target = expand_binop (mode, builtin_optab, op0, op1,
2113                          target, 0, OPTAB_DIRECT);
2114
2115   /* If we were unable to expand via the builtin, stop the sequence
2116      (without outputting the insns) and call to the library function
2117      with the stabilized argument list.  */
2118   if (target == 0)
2119     {
2120       end_sequence ();
2121       return expand_call (exp, target, target == const0_rtx);
2122     }
2123
2124   if (errno_set)
2125     expand_errno_check (exp, target);
2126
2127   /* Output the entire sequence.  */
2128   insns = get_insns ();
2129   end_sequence ();
2130   emit_insn (insns);
2131
2132   return target;
2133 }
2134
2135 /* Expand a call to the builtin sin and cos math functions.
2136    Return NULL_RTX if a normal call should be emitted rather than expanding the
2137    function in-line.  EXP is the expression that is a call to the builtin
2138    function; if convenient, the result should be placed in TARGET.
2139    SUBTARGET may be used as the target for computing one of EXP's
2140    operands.  */
2141
2142 static rtx
2143 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2144 {
2145   optab builtin_optab;
2146   rtx op0, insns;
2147   tree fndecl = get_callee_fndecl (exp);
2148   enum machine_mode mode;
2149   tree arg;
2150
2151   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2152     return NULL_RTX;
2153
2154   arg = CALL_EXPR_ARG (exp, 0);
2155
2156   switch (DECL_FUNCTION_CODE (fndecl))
2157     {
2158     CASE_FLT_FN (BUILT_IN_SIN):
2159     CASE_FLT_FN (BUILT_IN_COS):
2160       builtin_optab = sincos_optab; break;
2161     default:
2162       gcc_unreachable ();
2163     }
2164
2165   /* Make a suitable register to place result in.  */
2166   mode = TYPE_MODE (TREE_TYPE (exp));
2167
2168   /* Check if sincos insn is available, otherwise fallback
2169      to sin or cos insn.  */
2170   if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2171     switch (DECL_FUNCTION_CODE (fndecl))
2172       {
2173       CASE_FLT_FN (BUILT_IN_SIN):
2174         builtin_optab = sin_optab; break;
2175       CASE_FLT_FN (BUILT_IN_COS):
2176         builtin_optab = cos_optab; break;
2177       default:
2178         gcc_unreachable ();
2179       }
2180
2181   /* Before working hard, check whether the instruction is available.  */
2182   if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
2183     {
2184       target = gen_reg_rtx (mode);
2185
2186       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2187          need to expand the argument again.  This way, we will not perform
2188          side-effects more the once.  */
2189       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2190
2191       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2192
2193       start_sequence ();
2194
2195       /* Compute into TARGET.
2196          Set TARGET to wherever the result comes back.  */
2197       if (builtin_optab == sincos_optab)
2198         {
2199           int result;
2200
2201           switch (DECL_FUNCTION_CODE (fndecl))
2202             {
2203             CASE_FLT_FN (BUILT_IN_SIN):
2204               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2205               break;
2206             CASE_FLT_FN (BUILT_IN_COS):
2207               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2208               break;
2209             default:
2210               gcc_unreachable ();
2211             }
2212           gcc_assert (result);
2213         }
2214       else
2215         {
2216           target = expand_unop (mode, builtin_optab, op0, target, 0);
2217         }
2218
2219       if (target != 0)
2220         {
2221           /* Output the entire sequence.  */
2222           insns = get_insns ();
2223           end_sequence ();
2224           emit_insn (insns);
2225           return target;
2226         }
2227
2228       /* If we were unable to expand via the builtin, stop the sequence
2229          (without outputting the insns) and call to the library function
2230          with the stabilized argument list.  */
2231       end_sequence ();
2232     }
2233
2234   target = expand_call (exp, target, target == const0_rtx);
2235
2236   return target;
2237 }
2238
2239 /* Expand a call to one of the builtin math functions that operate on
2240    floating point argument and output an integer result (ilogb, isinf,
2241    isnan, etc).
2242    Return 0 if a normal call should be emitted rather than expanding the
2243    function in-line.  EXP is the expression that is a call to the builtin
2244    function; if convenient, the result should be placed in TARGET.
2245    SUBTARGET may be used as the target for computing one of EXP's operands.  */
2246
2247 static rtx
2248 expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
2249 {
2250   optab builtin_optab = 0;
2251   enum insn_code icode = CODE_FOR_nothing;
2252   rtx op0;
2253   tree fndecl = get_callee_fndecl (exp);
2254   enum machine_mode mode;
2255   bool errno_set = false;
2256   tree arg;
2257
2258   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2259     return NULL_RTX;
2260
2261   arg = CALL_EXPR_ARG (exp, 0);
2262
2263   switch (DECL_FUNCTION_CODE (fndecl))
2264     {
2265     CASE_FLT_FN (BUILT_IN_ILOGB):
2266       errno_set = true; builtin_optab = ilogb_optab; break;
2267     CASE_FLT_FN (BUILT_IN_ISINF):
2268       builtin_optab = isinf_optab; break;
2269     case BUILT_IN_ISNORMAL:
2270     case BUILT_IN_ISFINITE:
2271     CASE_FLT_FN (BUILT_IN_FINITE):
2272       /* These builtins have no optabs (yet).  */
2273       break;
2274     default:
2275       gcc_unreachable ();
2276     }
2277
2278   /* There's no easy way to detect the case we need to set EDOM.  */
2279   if (flag_errno_math && errno_set)
2280     return NULL_RTX;
2281
2282   /* Optab mode depends on the mode of the input argument.  */
2283   mode = TYPE_MODE (TREE_TYPE (arg));
2284
2285   if (builtin_optab)
2286     icode = optab_handler (builtin_optab, mode)->insn_code;
2287
2288   /* Before working hard, check whether the instruction is available.  */
2289   if (icode != CODE_FOR_nothing)
2290     {
2291       /* Make a suitable register to place result in.  */
2292       if (!target
2293           || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
2294          target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2295
2296       gcc_assert (insn_data[icode].operand[0].predicate
2297                   (target, GET_MODE (target)));
2298
2299       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2300          need to expand the argument again.  This way, we will not perform
2301          side-effects more the once.  */
2302       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2303
2304       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2305
2306       if (mode != GET_MODE (op0))
2307         op0 = convert_to_mode (mode, op0, 0);
2308
2309       /* Compute into TARGET.
2310          Set TARGET to wherever the result comes back.  */
2311       emit_unop_insn (icode, target, op0, UNKNOWN);
2312       return target;
2313     }
2314
2315   /* If there is no optab, try generic code.  */
2316   switch (DECL_FUNCTION_CODE (fndecl))
2317     {
2318       tree result;
2319
2320     CASE_FLT_FN (BUILT_IN_ISINF):
2321       {
2322         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
2323         tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
2324         tree const type = TREE_TYPE (arg);
2325         REAL_VALUE_TYPE r;
2326         char buf[128];
2327
2328         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
2329         real_from_string (&r, buf);
2330         result = build_call_expr (isgr_fn, 2,
2331                                   fold_build1 (ABS_EXPR, type, arg),
2332                                   build_real (type, r));
2333         return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
2334       }
2335     CASE_FLT_FN (BUILT_IN_FINITE):
2336     case BUILT_IN_ISFINITE:
2337       {
2338         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
2339         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
2340         tree const type = TREE_TYPE (arg);
2341         REAL_VALUE_TYPE r;
2342         char buf[128];
2343
2344         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
2345         real_from_string (&r, buf);
2346         result = build_call_expr (isle_fn, 2,
2347                                   fold_build1 (ABS_EXPR, type, arg),
2348                                   build_real (type, r));
2349         return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
2350       }
2351     case BUILT_IN_ISNORMAL:
2352       {
2353         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
2354            islessequal(fabs(x),DBL_MAX).  */
2355         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
2356         tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
2357         tree const type = TREE_TYPE (arg);
2358         REAL_VALUE_TYPE rmax, rmin;
2359         char buf[128];
2360
2361         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
2362         real_from_string (&rmax, buf);
2363         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
2364         real_from_string (&rmin, buf);
2365         arg = builtin_save_expr (fold_build1 (ABS_EXPR, type, arg));
2366         result = build_call_expr (isle_fn, 2, arg,
2367                                   build_real (type, rmax));
2368         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
2369                               build_call_expr (isge_fn, 2, arg,
2370                                                build_real (type, rmin)));
2371         return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
2372       }
2373     default:
2374       break;
2375     }
2376
2377   target = expand_call (exp, target, target == const0_rtx);
2378
2379   return target;
2380 }
2381
2382 /* Expand a call to the builtin sincos math function.
2383    Return NULL_RTX if a normal call should be emitted rather than expanding the
2384    function in-line.  EXP is the expression that is a call to the builtin
2385    function.  */
2386
2387 static rtx
2388 expand_builtin_sincos (tree exp)
2389 {
2390   rtx op0, op1, op2, target1, target2;
2391   enum machine_mode mode;
2392   tree arg, sinp, cosp;
2393   int result;
2394
2395   if (!validate_arglist (exp, REAL_TYPE,
2396                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2397     return NULL_RTX;
2398
2399   arg = CALL_EXPR_ARG (exp, 0);
2400   sinp = CALL_EXPR_ARG (exp, 1);
2401   cosp = CALL_EXPR_ARG (exp, 2);
2402
2403   /* Make a suitable register to place result in.  */
2404   mode = TYPE_MODE (TREE_TYPE (arg));
2405
2406   /* Check if sincos insn is available, otherwise emit the call.  */
2407   if (optab_handler (sincos_optab, mode)->insn_code == CODE_FOR_nothing)
2408     return NULL_RTX;
2409
2410   target1 = gen_reg_rtx (mode);
2411   target2 = gen_reg_rtx (mode);
2412
2413   op0 = expand_normal (arg);
2414   op1 = expand_normal (build_fold_indirect_ref (sinp));
2415   op2 = expand_normal (build_fold_indirect_ref (cosp));
2416
2417   /* Compute into target1 and target2.
2418      Set TARGET to wherever the result comes back.  */
2419   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2420   gcc_assert (result);
2421
2422   /* Move target1 and target2 to the memory locations indicated
2423      by op1 and op2.  */
2424   emit_move_insn (op1, target1);
2425   emit_move_insn (op2, target2);
2426
2427   return const0_rtx;
2428 }
2429
2430 /* Expand a call to the internal cexpi builtin to the sincos math function.
2431    EXP is the expression that is a call to the builtin function; if convenient,
2432    the result should be placed in TARGET.  SUBTARGET may be used as the target
2433    for computing one of EXP's operands.  */
2434
2435 static rtx
2436 expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
2437 {
2438   tree fndecl = get_callee_fndecl (exp);
2439   tree arg, type;
2440   enum machine_mode mode;
2441   rtx op0, op1, op2;
2442
2443   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2444     return NULL_RTX;
2445
2446   arg = CALL_EXPR_ARG (exp, 0);
2447   type = TREE_TYPE (arg);
2448   mode = TYPE_MODE (TREE_TYPE (arg));
2449
2450   /* Try expanding via a sincos optab, fall back to emitting a libcall
2451      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2452      is only generated from sincos, cexp or if we have either of them.  */
2453   if (optab_handler (sincos_optab, mode)->insn_code != CODE_FOR_nothing)
2454     {
2455       op1 = gen_reg_rtx (mode);
2456       op2 = gen_reg_rtx (mode);
2457
2458       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2459
2460       /* Compute into op1 and op2.  */
2461       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2462     }
2463   else if (TARGET_HAS_SINCOS)
2464     {
2465       tree call, fn = NULL_TREE;
2466       tree top1, top2;
2467       rtx op1a, op2a;
2468
2469       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2470         fn = built_in_decls[BUILT_IN_SINCOSF];
2471       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2472         fn = built_in_decls[BUILT_IN_SINCOS];
2473       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2474         fn = built_in_decls[BUILT_IN_SINCOSL];
2475       else
2476         gcc_unreachable ();
2477
2478       op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2479       op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2480       op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2481       op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2482       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2483       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2484
2485       /* Make sure not to fold the sincos call again.  */
2486       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2487       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2488                                       call, 3, arg, top1, top2));
2489     }
2490   else
2491     {
2492       tree call, fn = NULL_TREE, narg;
2493       tree ctype = build_complex_type (type);
2494
2495       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2496         fn = built_in_decls[BUILT_IN_CEXPF];
2497       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2498         fn = built_in_decls[BUILT_IN_CEXP];
2499       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2500         fn = built_in_decls[BUILT_IN_CEXPL];
2501       else
2502         gcc_unreachable ();
2503
2504       /* If we don't have a decl for cexp create one.  This is the
2505          friendliest fallback if the user calls __builtin_cexpi
2506          without full target C99 function support.  */
2507       if (fn == NULL_TREE)
2508         {
2509           tree fntype;
2510           const char *name = NULL;
2511
2512           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2513             name = "cexpf";
2514           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2515             name = "cexp";
2516           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2517             name = "cexpl";
2518
2519           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2520           fn = build_fn_decl (name, fntype);
2521         }
2522
2523       narg = fold_build2 (COMPLEX_EXPR, ctype,
2524                           build_real (type, dconst0), arg);
2525
2526       /* Make sure not to fold the cexp call again.  */
2527       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2528       return expand_expr (build_call_nary (ctype, call, 1, narg),
2529                           target, VOIDmode, EXPAND_NORMAL);
2530     }
2531
2532   /* Now build the proper return type.  */
2533   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2534                               make_tree (TREE_TYPE (arg), op2),
2535                               make_tree (TREE_TYPE (arg), op1)),
2536                       target, VOIDmode, EXPAND_NORMAL);
2537 }
2538
2539 /* Expand a call to one of the builtin rounding functions gcc defines
2540    as an extension (lfloor and lceil).  As these are gcc extensions we
2541    do not need to worry about setting errno to EDOM.
2542    If expanding via optab fails, lower expression to (int)(floor(x)).
2543    EXP is the expression that is a call to the builtin function;
2544    if convenient, the result should be placed in TARGET.  */
2545
2546 static rtx
2547 expand_builtin_int_roundingfn (tree exp, rtx target)
2548 {
2549   convert_optab builtin_optab;
2550   rtx op0, insns, tmp;
2551   tree fndecl = get_callee_fndecl (exp);
2552   enum built_in_function fallback_fn;
2553   tree fallback_fndecl;
2554   enum machine_mode mode;
2555   tree arg;
2556
2557   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2558     gcc_unreachable ();
2559
2560   arg = CALL_EXPR_ARG (exp, 0);
2561
2562   switch (DECL_FUNCTION_CODE (fndecl))
2563     {
2564     CASE_FLT_FN (BUILT_IN_LCEIL):
2565     CASE_FLT_FN (BUILT_IN_LLCEIL):
2566       builtin_optab = lceil_optab;
2567       fallback_fn = BUILT_IN_CEIL;
2568       break;
2569
2570     CASE_FLT_FN (BUILT_IN_LFLOOR):
2571     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2572       builtin_optab = lfloor_optab;
2573       fallback_fn = BUILT_IN_FLOOR;
2574       break;
2575
2576     default:
2577       gcc_unreachable ();
2578     }
2579
2580   /* Make a suitable register to place result in.  */
2581   mode = TYPE_MODE (TREE_TYPE (exp));
2582
2583   target = gen_reg_rtx (mode);
2584
2585   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2586      need to expand the argument again.  This way, we will not perform
2587      side-effects more the once.  */
2588   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2589
2590   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2591
2592   start_sequence ();
2593
2594   /* Compute into TARGET.  */
2595   if (expand_sfix_optab (target, op0, builtin_optab))
2596     {
2597       /* Output the entire sequence.  */
2598       insns = get_insns ();
2599       end_sequence ();
2600       emit_insn (insns);
2601       return target;
2602     }
2603
2604   /* If we were unable to expand via the builtin, stop the sequence
2605      (without outputting the insns).  */
2606   end_sequence ();
2607
2608   /* Fall back to floating point rounding optab.  */
2609   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2610
2611   /* For non-C99 targets we may end up without a fallback fndecl here
2612      if the user called __builtin_lfloor directly.  In this case emit
2613      a call to the floor/ceil variants nevertheless.  This should result
2614      in the best user experience for not full C99 targets.  */
2615   if (fallback_fndecl == NULL_TREE)
2616     {
2617       tree fntype;
2618       const char *name = NULL;
2619
2620       switch (DECL_FUNCTION_CODE (fndecl))
2621         {
2622         case BUILT_IN_LCEIL:
2623         case BUILT_IN_LLCEIL:
2624           name = "ceil";
2625           break;
2626         case BUILT_IN_LCEILF:
2627         case BUILT_IN_LLCEILF:
2628           name = "ceilf";
2629           break;
2630         case BUILT_IN_LCEILL:
2631         case BUILT_IN_LLCEILL:
2632           name = "ceill";
2633           break;
2634         case BUILT_IN_LFLOOR:
2635         case BUILT_IN_LLFLOOR:
2636           name = "floor";
2637           break;
2638         case BUILT_IN_LFLOORF:
2639         case BUILT_IN_LLFLOORF:
2640           name = "floorf";
2641           break;
2642         case BUILT_IN_LFLOORL:
2643         case BUILT_IN_LLFLOORL:
2644           name = "floorl";
2645           break;
2646         default:
2647           gcc_unreachable ();
2648         }
2649
2650       fntype = build_function_type_list (TREE_TYPE (arg),
2651                                          TREE_TYPE (arg), NULL_TREE);
2652       fallback_fndecl = build_fn_decl (name, fntype);
2653     }
2654
2655   exp = build_call_expr (fallback_fndecl, 1, arg);
2656
2657   tmp = expand_normal (exp);
2658
2659   /* Truncate the result of floating point optab to integer
2660      via expand_fix ().  */
2661   target = gen_reg_rtx (mode);
2662   expand_fix (target, tmp, 0);
2663
2664   return target;
2665 }
2666
2667 /* Expand a call to one of the builtin math functions doing integer
2668    conversion (lrint).
2669    Return 0 if a normal call should be emitted rather than expanding the
2670    function in-line.  EXP is the expression that is a call to the builtin
2671    function; if convenient, the result should be placed in TARGET.  */
2672
2673 static rtx
2674 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2675 {
2676   convert_optab builtin_optab;
2677   rtx op0, insns;
2678   tree fndecl = get_callee_fndecl (exp);
2679   tree arg;
2680   enum machine_mode mode;
2681
2682   /* There's no easy way to detect the case we need to set EDOM.  */
2683   if (flag_errno_math)
2684     return NULL_RTX;
2685
2686   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2687      gcc_unreachable ();
2688
2689   arg = CALL_EXPR_ARG (exp, 0);
2690
2691   switch (DECL_FUNCTION_CODE (fndecl))
2692     {
2693     CASE_FLT_FN (BUILT_IN_LRINT):
2694     CASE_FLT_FN (BUILT_IN_LLRINT):
2695       builtin_optab = lrint_optab; break;
2696     CASE_FLT_FN (BUILT_IN_LROUND):
2697     CASE_FLT_FN (BUILT_IN_LLROUND):
2698       builtin_optab = lround_optab; break;
2699     default:
2700       gcc_unreachable ();
2701     }
2702
2703   /* Make a suitable register to place result in.  */
2704   mode = TYPE_MODE (TREE_TYPE (exp));
2705
2706   target = gen_reg_rtx (mode);
2707
2708   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2709      need to expand the argument again.  This way, we will not perform
2710      side-effects more the once.  */
2711   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2712
2713   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2714
2715   start_sequence ();
2716
2717   if (expand_sfix_optab (target, op0, builtin_optab))
2718     {
2719       /* Output the entire sequence.  */
2720       insns = get_insns ();
2721       end_sequence ();
2722       emit_insn (insns);
2723       return target;
2724     }
2725
2726   /* If we were unable to expand via the builtin, stop the sequence
2727      (without outputting the insns) and call to the library function
2728      with the stabilized argument list.  */
2729   end_sequence ();
2730
2731   target = expand_call (exp, target, target == const0_rtx);
2732
2733   return target;
2734 }
2735
2736 /* To evaluate powi(x,n), the floating point value x raised to the
2737    constant integer exponent n, we use a hybrid algorithm that
2738    combines the "window method" with look-up tables.  For an
2739    introduction to exponentiation algorithms and "addition chains",
2740    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2741    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2742    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2743    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2744
2745 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2746    multiplications to inline before calling the system library's pow
2747    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2748    so this default never requires calling pow, powf or powl.  */
2749
2750 #ifndef POWI_MAX_MULTS
2751 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2752 #endif
2753
2754 /* The size of the "optimal power tree" lookup table.  All
2755    exponents less than this value are simply looked up in the
2756    powi_table below.  This threshold is also used to size the
2757    cache of pseudo registers that hold intermediate results.  */
2758 #define POWI_TABLE_SIZE 256
2759
2760 /* The size, in bits of the window, used in the "window method"
2761    exponentiation algorithm.  This is equivalent to a radix of
2762    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2763 #define POWI_WINDOW_SIZE 3
2764
2765 /* The following table is an efficient representation of an
2766    "optimal power tree".  For each value, i, the corresponding
2767    value, j, in the table states than an optimal evaluation
2768    sequence for calculating pow(x,i) can be found by evaluating
2769    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2770    100 integers is given in Knuth's "Seminumerical algorithms".  */
2771
2772 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2773   {
2774       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2775       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2776       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2777      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2778      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2779      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2780      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2781      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2782      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2783      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2784      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2785      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2786      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2787      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2788      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2789      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2790      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2791      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2792      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2793      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2794      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2795      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2796      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2797      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2798      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2799     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2800     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2801     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2802     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2803     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2804     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2805     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2806   };
2807
2808
2809 /* Return the number of multiplications required to calculate
2810    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2811    subroutine of powi_cost.  CACHE is an array indicating
2812    which exponents have already been calculated.  */
2813
2814 static int
2815 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2816 {
2817   /* If we've already calculated this exponent, then this evaluation
2818      doesn't require any additional multiplications.  */
2819   if (cache[n])
2820     return 0;
2821
2822   cache[n] = true;
2823   return powi_lookup_cost (n - powi_table[n], cache)
2824          + powi_lookup_cost (powi_table[n], cache) + 1;
2825 }
2826
2827 /* Return the number of multiplications required to calculate
2828    powi(x,n) for an arbitrary x, given the exponent N.  This
2829    function needs to be kept in sync with expand_powi below.  */
2830
2831 static int
2832 powi_cost (HOST_WIDE_INT n)
2833 {
2834   bool cache[POWI_TABLE_SIZE];
2835   unsigned HOST_WIDE_INT digit;
2836   unsigned HOST_WIDE_INT val;
2837   int result;
2838
2839   if (n == 0)
2840     return 0;
2841
2842   /* Ignore the reciprocal when calculating the cost.  */
2843   val = (n < 0) ? -n : n;
2844
2845   /* Initialize the exponent cache.  */
2846   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2847   cache[1] = true;
2848
2849   result = 0;
2850
2851   while (val >= POWI_TABLE_SIZE)
2852     {
2853       if (val & 1)
2854         {
2855           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2856           result += powi_lookup_cost (digit, cache)
2857                     + POWI_WINDOW_SIZE + 1;
2858           val >>= POWI_WINDOW_SIZE;
2859         }
2860       else
2861         {
2862           val >>= 1;
2863           result++;
2864         }
2865     }
2866
2867   return result + powi_lookup_cost (val, cache);
2868 }
2869
2870 /* Recursive subroutine of expand_powi.  This function takes the array,
2871    CACHE, of already calculated exponents and an exponent N and returns
2872    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2873
2874 static rtx
2875 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2876 {
2877   unsigned HOST_WIDE_INT digit;
2878   rtx target, result;
2879   rtx op0, op1;
2880
2881   if (n < POWI_TABLE_SIZE)
2882     {
2883       if (cache[n])
2884         return cache[n];
2885
2886       target = gen_reg_rtx (mode);
2887       cache[n] = target;
2888
2889       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2890       op1 = expand_powi_1 (mode, powi_table[n], cache);
2891     }
2892   else if (n & 1)
2893     {
2894       target = gen_reg_rtx (mode);
2895       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2896       op0 = expand_powi_1 (mode, n - digit, cache);
2897       op1 = expand_powi_1 (mode, digit, cache);
2898     }
2899   else
2900     {
2901       target = gen_reg_rtx (mode);
2902       op0 = expand_powi_1 (mode, n >> 1, cache);
2903       op1 = op0;
2904     }
2905
2906   result = expand_mult (mode, op0, op1, target, 0);
2907   if (result != target)
2908     emit_move_insn (target, result);
2909   return target;
2910 }
2911
2912 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
2913    floating point operand in mode MODE, and N is the exponent.  This
2914    function needs to be kept in sync with powi_cost above.  */
2915
2916 static rtx
2917 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2918 {
2919   unsigned HOST_WIDE_INT val;
2920   rtx cache[POWI_TABLE_SIZE];
2921   rtx result;
2922
2923   if (n == 0)
2924     return CONST1_RTX (mode);
2925
2926   val = (n < 0) ? -n : n;
2927
2928   memset (cache, 0, sizeof (cache));
2929   cache[1] = x;
2930
2931   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2932
2933   /* If the original exponent was negative, reciprocate the result.  */
2934   if (n < 0)
2935     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2936                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2937
2938   return result;
2939 }
2940
2941 /* Expand a call to the pow built-in mathematical function.  Return NULL_RTX if
2942    a normal call should be emitted rather than expanding the function
2943    in-line.  EXP is the expression that is a call to the builtin
2944    function; if convenient, the result should be placed in TARGET.  */
2945
2946 static rtx
2947 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2948 {
2949   tree arg0, arg1;
2950   tree fn, narg0;
2951   tree type = TREE_TYPE (exp);
2952   REAL_VALUE_TYPE cint, c, c2;
2953   HOST_WIDE_INT n;
2954   rtx op, op2;
2955   enum machine_mode mode = TYPE_MODE (type);
2956
2957   if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2958     return NULL_RTX;
2959
2960   arg0 = CALL_EXPR_ARG (exp, 0);
2961   arg1 = CALL_EXPR_ARG (exp, 1);
2962
2963   if (TREE_CODE (arg1) != REAL_CST
2964       || TREE_OVERFLOW (arg1))
2965     return expand_builtin_mathfn_2 (exp, target, subtarget);
2966
2967   /* Handle constant exponents.  */
2968
2969   /* For integer valued exponents we can expand to an optimal multiplication
2970      sequence using expand_powi.  */
2971   c = TREE_REAL_CST (arg1);
2972   n = real_to_integer (&c);
2973   real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2974   if (real_identical (&c, &cint)
2975       && ((n >= -1 && n <= 2)
2976           || (flag_unsafe_math_optimizations
2977               && optimize_insn_for_speed_p ()
2978               && powi_cost (n) <= POWI_MAX_MULTS)))
2979     {
2980       op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2981       if (n != 1)
2982         {
2983           op = force_reg (mode, op);
2984           op = expand_powi (op, mode, n);
2985         }
2986       return op;
2987     }
2988
2989   narg0 = builtin_save_expr (arg0);
2990
2991   /* If the exponent is not integer valued, check if it is half of an integer.
2992      In this case we can expand to sqrt (x) * x**(n/2).  */
2993   fn = mathfn_built_in (type, BUILT_IN_SQRT);
2994   if (fn != NULL_TREE)
2995     {
2996       real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
2997       n = real_to_integer (&c2);
2998       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2999       if (real_identical (&c2, &cint)
3000           && ((flag_unsafe_math_optimizations
3001                && optimize_insn_for_speed_p ()
3002                && powi_cost (n/2) <= POWI_MAX_MULTS)
3003               || n == 1))
3004         {
3005           tree call_expr = build_call_expr (fn, 1, narg0);
3006           /* Use expand_expr in case the newly built call expression
3007              was folded to a non-call.  */
3008           op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
3009           if (n != 1)
3010             {
3011               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3012               op2 = force_reg (mode, op2);
3013               op2 = expand_powi (op2, mode, abs (n / 2));
3014               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3015                                         0, OPTAB_LIB_WIDEN);
3016               /* If the original exponent was negative, reciprocate the
3017                  result.  */
3018               if (n < 0)
3019                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3020                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3021             }
3022           return op;
3023         }
3024     }
3025
3026   /* Try if the exponent is a third of an integer.  In this case
3027      we can expand to x**(n/3) * cbrt(x)**(n%3).  As cbrt (x) is
3028      different from pow (x, 1./3.) due to rounding and behavior
3029      with negative x we need to constrain this transformation to
3030      unsafe math and positive x or finite math.  */
3031   fn = mathfn_built_in (type, BUILT_IN_CBRT);
3032   if (fn != NULL_TREE
3033       && flag_unsafe_math_optimizations
3034       && (tree_expr_nonnegative_p (arg0)
3035           || !HONOR_NANS (mode)))
3036     {
3037       REAL_VALUE_TYPE dconst3;
3038       real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3039       real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3040       real_round (&c2, mode, &c2);
3041       n = real_to_integer (&c2);
3042       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3043       real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3044       real_convert (&c2, mode, &c2);
3045       if (real_identical (&c2, &c)
3046           && ((optimize_insn_for_speed_p ()
3047                && powi_cost (n/3) <= POWI_MAX_MULTS)
3048               || n == 1))
3049         {
3050           tree call_expr = build_call_expr (fn, 1,narg0);
3051           op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3052           if (abs (n) % 3 == 2)
3053             op = expand_simple_binop (mode, MULT, op, op, op,
3054                                       0, OPTAB_LIB_WIDEN);
3055           if (n != 1)
3056             {
3057               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3058               op2 = force_reg (mode, op2);
3059               op2 = expand_powi (op2, mode, abs (n / 3));
3060               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3061                                         0, OPTAB_LIB_WIDEN);
3062               /* If the original exponent was negative, reciprocate the
3063                  result.  */
3064               if (n < 0)
3065                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3066                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3067             }
3068           return op;
3069         }
3070     }
3071
3072   /* Fall back to optab expansion.  */
3073   return expand_builtin_mathfn_2 (exp, target, subtarget);
3074 }
3075
3076 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
3077    a normal call should be emitted rather than expanding the function
3078    in-line.  EXP is the expression that is a call to the builtin
3079    function; if convenient, the result should be placed in TARGET.  */
3080
3081 static rtx
3082 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
3083 {
3084   tree arg0, arg1;
3085   rtx op0, op1;
3086   enum machine_mode mode;
3087   enum machine_mode mode2;
3088
3089   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3090     return NULL_RTX;
3091
3092   arg0 = CALL_EXPR_ARG (exp, 0);
3093   arg1 = CALL_EXPR_ARG (exp, 1);
3094   mode = TYPE_MODE (TREE_TYPE (exp));
3095
3096   /* Handle constant power.  */
3097
3098   if (TREE_CODE (arg1) == INTEGER_CST
3099       && !TREE_OVERFLOW (arg1))
3100     {
3101       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3102
3103       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3104          Otherwise, check the number of multiplications required.  */
3105       if ((TREE_INT_CST_HIGH (arg1) == 0
3106            || TREE_INT_CST_HIGH (arg1) == -1)
3107           && ((n >= -1 && n <= 2)
3108               || (optimize_insn_for_speed_p ()
3109                   && powi_cost (n) <= POWI_MAX_MULTS)))
3110         {
3111           op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3112           op0 = force_reg (mode, op0);
3113           return expand_powi (op0, mode, n);
3114         }
3115     }
3116
3117   /* Emit a libcall to libgcc.  */
3118
3119   /* Mode of the 2nd argument must match that of an int.  */
3120   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3121
3122   if (target == NULL_RTX)
3123     target = gen_reg_rtx (mode);
3124
3125   op0 = expand_expr (arg0, subtarget, mode, EXPAND_NORMAL);
3126   if (GET_MODE (op0) != mode)
3127     op0 = convert_to_mode (mode, op0, 0);
3128   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3129   if (GET_MODE (op1) != mode2)
3130     op1 = convert_to_mode (mode2, op1, 0);
3131
3132   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3133                                     target, LCT_CONST, mode, 2,
3134                                     op0, mode, op1, mode2);
3135
3136   return target;
3137 }
3138
3139 /* Expand expression EXP which is a call to the strlen builtin.  Return
3140    NULL_RTX if we failed the caller should emit a normal call, otherwise
3141    try to get the result in TARGET, if convenient.  */
3142
3143 static rtx
3144 expand_builtin_strlen (tree exp, rtx target,
3145                        enum machine_mode target_mode)
3146 {
3147   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3148     return NULL_RTX;
3149   else
3150     {
3151       rtx pat;
3152       tree len;
3153       tree src = CALL_EXPR_ARG (exp, 0);
3154       rtx result, src_reg, char_rtx, before_strlen;
3155       enum machine_mode insn_mode = target_mode, char_mode;
3156       enum insn_code icode = CODE_FOR_nothing;
3157       int align;
3158
3159       /* If the length can be computed at compile-time, return it.  */
3160       len = c_strlen (src, 0);
3161       if (len)
3162         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3163
3164       /* If the length can be computed at compile-time and is constant
3165          integer, but there are side-effects in src, evaluate
3166          src for side-effects, then return len.
3167          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3168          can be optimized into: i++; x = 3;  */
3169       len = c_strlen (src, 1);
3170       if (len && TREE_CODE (len) == INTEGER_CST)
3171         {
3172           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3173           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3174         }
3175
3176       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3177
3178       /* If SRC is not a pointer type, don't do this operation inline.  */
3179       if (align == 0)
3180         return NULL_RTX;
3181
3182       /* Bail out if we can't compute strlen in the right mode.  */
3183       while (insn_mode != VOIDmode)
3184         {
3185           icode = optab_handler (strlen_optab, insn_mode)->insn_code;
3186           if (icode != CODE_FOR_nothing)
3187             break;
3188
3189           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3190         }
3191       if (insn_mode == VOIDmode)
3192         return NULL_RTX;
3193
3194       /* Make a place to write the result of the instruction.  */
3195       result = target;
3196       if (! (result != 0
3197              && REG_P (result)
3198              && GET_MODE (result) == insn_mode
3199              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3200         result = gen_reg_rtx (insn_mode);
3201
3202       /* Make a place to hold the source address.  We will not expand
3203          the actual source until we are sure that the expansion will
3204          not fail -- there are trees that cannot be expanded twice.  */
3205       src_reg = gen_reg_rtx (Pmode);
3206
3207       /* Mark the beginning of the strlen sequence so we can emit the
3208          source operand later.  */
3209       before_strlen = get_last_insn ();
3210
3211       char_rtx = const0_rtx;
3212       char_mode = insn_data[(int) icode].operand[2].mode;
3213       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3214                                                             char_mode))
3215         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3216
3217       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3218                              char_rtx, GEN_INT (align));
3219       if (! pat)
3220         return NULL_RTX;
3221       emit_insn (pat);
3222
3223       /* Now that we are assured of success, expand the source.  */
3224       start_sequence ();
3225       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3226       if (pat != src_reg)
3227         emit_move_insn (src_reg, pat);
3228       pat = get_insns ();
3229       end_sequence ();
3230
3231       if (before_strlen)
3232         emit_insn_after (pat, before_strlen);
3233       else
3234         emit_insn_before (pat, get_insns ());
3235
3236       /* Return the value in the proper mode for this function.  */
3237       if (GET_MODE (result) == target_mode)
3238         target = result;
3239       else if (target != 0)
3240         convert_move (target, result, 0);
3241       else
3242         target = convert_to_mode (target_mode, result, 0);
3243
3244       return target;
3245     }
3246 }
3247
3248 /* Expand a call to the strstr builtin.  Return NULL_RTX if we failed the
3249    caller should emit a normal call, otherwise try to get the result
3250    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3251
3252 static rtx
3253 expand_builtin_strstr (tree exp, rtx target, enum machine_mode mode)
3254 {
3255   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3256     {
3257       tree type = TREE_TYPE (exp);
3258       tree result = fold_builtin_strstr (CALL_EXPR_ARG (exp, 0),
3259                                          CALL_EXPR_ARG (exp, 1), type);
3260       if (result)
3261         return expand_expr (result, target, mode, EXPAND_NORMAL);
3262     }
3263   return NULL_RTX;
3264 }
3265
3266 /* Expand a call to the strchr builtin.  Return NULL_RTX if we failed the
3267    caller should emit a normal call, otherwise try to get the result
3268    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3269
3270 static rtx
3271 expand_builtin_strchr (tree exp, rtx target, enum machine_mode mode)
3272 {
3273   if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3274     {
3275       tree type = TREE_TYPE (exp);
3276       tree result = fold_builtin_strchr (CALL_EXPR_ARG (exp, 0),
3277                                          CALL_EXPR_ARG (exp, 1), type);
3278       if (result)
3279         return expand_expr (result, target, mode, EXPAND_NORMAL);
3280
3281       /* FIXME: Should use strchrM optab so that ports can optimize this.  */
3282     }
3283   return NULL_RTX;
3284 }
3285
3286 /* Expand a call to the strrchr builtin.  Return NULL_RTX if we failed the
3287    caller should emit a normal call, otherwise try to get the result
3288    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3289
3290 static rtx
3291 expand_builtin_strrchr (tree exp, rtx target, enum machine_mode mode)
3292 {
3293   if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3294     {
3295       tree type = TREE_TYPE (exp);
3296       tree result = fold_builtin_strrchr (CALL_EXPR_ARG (exp, 0),
3297                                           CALL_EXPR_ARG (exp, 1), type);
3298       if (result)
3299         return expand_expr (result, target, mode, EXPAND_NORMAL);
3300     }
3301   return NULL_RTX;
3302 }
3303
3304 /* Expand a call to the strpbrk builtin.  Return NULL_RTX if we failed the
3305    caller should emit a normal call, otherwise try to get the result
3306    in TARGET, if convenient (and in mode MODE if that's convenient).  */
3307
3308 static rtx
3309 expand_builtin_strpbrk (tree exp, rtx target, enum machine_mode mode)
3310 {
3311   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3312     {
3313       tree type = TREE_TYPE (exp);
3314       tree result = fold_builtin_strpbrk (CALL_EXPR_ARG (exp, 0),
3315                                           CALL_EXPR_ARG (exp, 1), type);
3316       if (result)
3317         return expand_expr (result, target, mode, EXPAND_NORMAL);
3318     }
3319   return NULL_RTX;
3320 }
3321
3322 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3323    bytes from constant string DATA + OFFSET and return it as target
3324    constant.  */
3325
3326 static rtx
3327 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3328                          enum machine_mode mode)
3329 {
3330   const char *str = (const char *) data;
3331
3332   gcc_assert (offset >= 0
3333               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3334                   <= strlen (str) + 1));
3335
3336   return c_readstr (str + offset, mode);
3337 }
3338
3339 /* Expand a call EXP to the memcpy builtin.
3340    Return NULL_RTX if we failed, the caller should emit a normal call,
3341    otherwise try to get the result in TARGET, if convenient (and in
3342    mode MODE if that's convenient).  */
3343
3344 static rtx
3345 expand_builtin_memcpy (tree exp, rtx target, enum machine_mode mode)
3346 {
3347   tree fndecl = get_callee_fndecl (exp);
3348
3349   if (!validate_arglist (exp,
3350                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3351     return NULL_RTX;
3352   else
3353     {
3354       tree dest = CALL_EXPR_ARG (exp, 0);
3355       tree src = CALL_EXPR_ARG (exp, 1);
3356       tree len = CALL_EXPR_ARG (exp, 2);
3357       const char *src_str;
3358       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3359       unsigned int dest_align
3360         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3361       rtx dest_mem, src_mem, dest_addr, len_rtx;
3362       tree result = fold_builtin_memory_op (dest, src, len,
3363                                             TREE_TYPE (TREE_TYPE (fndecl)),
3364                                             false, /*endp=*/0);
3365       HOST_WIDE_INT expected_size = -1;
3366       unsigned int expected_align = 0;
3367       tree_ann_common_t ann;
3368
3369       if (result)
3370         {
3371           while (TREE_CODE (result) == COMPOUND_EXPR)
3372             {
3373               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3374                            EXPAND_NORMAL);
3375               result = TREE_OPERAND (result, 1);
3376             }
3377           return expand_expr (result, target, mode, EXPAND_NORMAL);
3378         }
3379
3380       /* If DEST is not a pointer type, call the normal function.  */
3381       if (dest_align == 0)
3382         return NULL_RTX;
3383
3384       /* If either SRC is not a pointer type, don't do this
3385          operation in-line.  */
3386       if (src_align == 0)
3387         return NULL_RTX;
3388
3389       ann = tree_common_ann (exp);
3390       if (ann)
3391         stringop_block_profile (ann->stmt, &expected_align, &expected_size);
3392
3393       if (expected_align < dest_align)
3394         expected_align = dest_align;
3395       dest_mem = get_memory_rtx (dest, len);
3396       set_mem_align (dest_mem, dest_align);
3397       len_rtx = expand_normal (len);
3398       src_str = c_getstr (src);
3399
3400       /* If SRC is a string constant and block move would be done
3401          by pieces, we can avoid loading the string from memory
3402          and only stored the computed constants.  */
3403       if (src_str
3404           && GET_CODE (len_rtx) == CONST_INT
3405           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3406           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3407                                   CONST_CAST (char *, src_str),
3408                                   dest_align, false))
3409         {
3410           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3411                                       builtin_memcpy_read_str,
3412                                       CONST_CAST (char *, src_str),
3413                                       dest_align, false, 0);
3414           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3415           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3416           return dest_mem;
3417         }
3418
3419       src_mem = get_memory_rtx (src, len);
3420       set_mem_align (src_mem, src_align);
3421
3422       /* Copy word part most expediently.  */
3423       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3424                                          CALL_EXPR_TAILCALL (exp)
3425                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3426                                          expected_align, expected_size);
3427
3428       if (dest_addr == 0)
3429         {
3430           dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3431           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3432         }
3433       return dest_addr;
3434     }
3435 }
3436
3437 /* Expand a call EXP to the mempcpy builtin.
3438    Return NULL_RTX if we failed; the caller should emit a normal call,
3439    otherwise try to get the result in TARGET, if convenient (and in
3440    mode MODE if that's convenient).  If ENDP is 0 return the
3441    destination pointer, if ENDP is 1 return the end pointer ala
3442    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3443    stpcpy.  */
3444
3445 static rtx
3446 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3447 {
3448   if (!validate_arglist (exp,
3449                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3450     return NULL_RTX;
3451   else
3452     {
3453       tree dest = CALL_EXPR_ARG (exp, 0);
3454       tree src = CALL_EXPR_ARG (exp, 1);
3455       tree len = CALL_EXPR_ARG (exp, 2);
3456       return expand_builtin_mempcpy_args (dest, src, len,
3457                                           TREE_TYPE (exp),
3458                                           target, mode, /*endp=*/ 1);
3459     }
3460 }
3461
3462 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3463    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3464    so that this can also be called without constructing an actual CALL_EXPR.
3465    TYPE is the return type of the call.  The other arguments and return value
3466    are the same as for expand_builtin_mempcpy.  */
3467
3468 static rtx
3469 expand_builtin_mempcpy_args (tree dest, tree src, tree len, tree type,
3470                              rtx target, enum machine_mode mode, int endp)
3471 {
3472     /* If return value is ignored, transform mempcpy into memcpy.  */
3473   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3474     {
3475       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3476       tree result = build_call_expr (fn, 3, dest, src, len);
3477
3478       while (TREE_CODE (result) == COMPOUND_EXPR)
3479         {
3480           expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3481                        EXPAND_NORMAL);
3482           result = TREE_OPERAND (result, 1);
3483         }
3484       return expand_expr (result, target, mode, EXPAND_NORMAL);
3485     }
3486   else
3487     {
3488       const char *src_str;
3489       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3490       unsigned int dest_align
3491         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3492       rtx dest_mem, src_mem, len_rtx;
3493       tree result = fold_builtin_memory_op (dest, src, len, type, false, endp);
3494
3495       if (result)
3496         {
3497           while (TREE_CODE (result) == COMPOUND_EXPR)
3498             {
3499               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3500                            EXPAND_NORMAL);
3501               result = TREE_OPERAND (result, 1);
3502             }
3503           return expand_expr (result, target, mode, EXPAND_NORMAL);
3504         }
3505
3506       /* If either SRC or DEST is not a pointer type, don't do this
3507          operation in-line.  */
3508       if (dest_align == 0 || src_align == 0)
3509         return NULL_RTX;
3510
3511       /* If LEN is not constant, call the normal function.  */
3512       if (! host_integerp (len, 1))
3513         return NULL_RTX;
3514
3515       len_rtx = expand_normal (len);
3516       src_str = c_getstr (src);
3517
3518       /* If SRC is a string constant and block move would be done
3519          by pieces, we can avoid loading the string from memory
3520          and only stored the computed constants.  */
3521       if (src_str
3522           && GET_CODE (len_rtx) == CONST_INT
3523           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3524           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3525                                   CONST_CAST (char *, src_str),
3526                                   dest_align, false))
3527         {
3528           dest_mem = get_memory_rtx (dest, len);
3529           set_mem_align (dest_mem, dest_align);
3530           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3531                                       builtin_memcpy_read_str,
3532                                       CONST_CAST (char *, src_str),
3533                                       dest_align, false, endp);
3534           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3535           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3536           return dest_mem;
3537         }
3538
3539       if (GET_CODE (len_rtx) == CONST_INT
3540           && can_move_by_pieces (INTVAL (len_rtx),
3541                                  MIN (dest_align, src_align)))
3542         {
3543           dest_mem = get_memory_rtx (dest, len);
3544           set_mem_align (dest_mem, dest_align);
3545           src_mem = get_memory_rtx (src, len);
3546           set_mem_align (src_mem, src_align);
3547           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3548                                      MIN (dest_align, src_align), endp);
3549           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3550           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3551           return dest_mem;
3552         }
3553
3554       return NULL_RTX;
3555     }
3556 }
3557
3558 /* Expand expression EXP, which is a call to the memmove builtin.  Return
3559    NULL_RTX if we failed; the caller should emit a normal call.  */
3560
3561 static rtx
3562 expand_builtin_memmove (tree exp, rtx target, enum machine_mode mode, int ignore)
3563 {
3564   if (!validate_arglist (exp,
3565                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3566     return NULL_RTX;
3567   else
3568     {
3569       tree dest = CALL_EXPR_ARG (exp, 0);
3570       tree src = CALL_EXPR_ARG (exp, 1);
3571       tree len = CALL_EXPR_ARG (exp, 2);
3572       return expand_builtin_memmove_args (dest, src, len, TREE_TYPE (exp),
3573                                           target, mode, ignore);
3574     }
3575 }
3576
3577 /* Helper function to do the actual work for expand_builtin_memmove.  The
3578    arguments to the builtin_memmove call DEST, SRC, and LEN are broken out
3579    so that this can also be called without constructing an actual CALL_EXPR.
3580    TYPE is the return type of the call.  The other arguments and return value
3581    are the same as for expand_builtin_memmove.  */
3582
3583 static rtx
3584 expand_builtin_memmove_args (tree dest, tree src, tree len,
3585                              tree type, rtx target, enum machine_mode mode,
3586                              int ignore)
3587 {
3588   tree result = fold_builtin_memory_op (dest, src, len, type, ignore, /*endp=*/3);
3589
3590   if (result)
3591     {
3592       STRIP_TYPE_NOPS (result);
3593       while (TREE_CODE (result) == COMPOUND_EXPR)
3594         {
3595           expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3596                        EXPAND_NORMAL);
3597           result = TREE_OPERAND (result, 1);
3598         }
3599       return expand_expr (result, target, mode, EXPAND_NORMAL);
3600     }
3601
3602   /* Otherwise, call the normal function.  */
3603   return NULL_RTX;
3604 }
3605
3606 /* Expand expression EXP, which is a call to the bcopy builtin.  Return
3607    NULL_RTX if we failed the caller should emit a normal call.  */
3608
3609 static rtx
3610 expand_builtin_bcopy (tree exp, int ignore)
3611 {
3612   tree type = TREE_TYPE (exp);
3613   tree src, dest, size;
3614
3615   if (!validate_arglist (exp,
3616                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3617     return NULL_RTX;
3618
3619   src = CALL_EXPR_ARG (exp, 0);
3620   dest = CALL_EXPR_ARG (exp, 1);
3621   size = CALL_EXPR_ARG (exp, 2);
3622
3623   /* Transform bcopy(ptr x, ptr y, int z) to memmove(ptr y, ptr x, size_t z).
3624      This is done this way so that if it isn't expanded inline, we fall
3625      back to calling bcopy instead of memmove.  */
3626   return expand_builtin_memmove_args (dest, src,
3627                                       fold_convert (sizetype, size),
3628                                       type, const0_rtx, VOIDmode,
3629                                       ignore);
3630 }
3631
3632 #ifndef HAVE_movstr
3633 # define HAVE_movstr 0
3634 # define CODE_FOR_movstr CODE_FOR_nothing
3635 #endif
3636
3637 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3638    we failed, the caller should emit a normal call, otherwise try to
3639    get the result in TARGET, if convenient.  If ENDP is 0 return the
3640    destination pointer, if ENDP is 1 return the end pointer ala
3641    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3642    stpcpy.  */
3643
3644 static rtx
3645 expand_movstr (tree dest, tree src, rtx target, int endp)
3646 {
3647   rtx end;
3648   rtx dest_mem;
3649   rtx src_mem;
3650   rtx insn;
3651   const struct insn_data * data;
3652
3653   if (!HAVE_movstr)
3654     return NULL_RTX;
3655
3656   dest_mem = get_memory_rtx (dest, NULL);
3657   src_mem = get_memory_rtx (src, NULL);
3658   if (!endp)
3659     {
3660       target = force_reg (Pmode, XEXP (dest_mem, 0));
3661       dest_mem = replace_equiv_address (dest_mem, target);
3662       end = gen_reg_rtx (Pmode);
3663     }
3664   else
3665     {
3666       if (target == 0 || target == const0_rtx)
3667         {
3668           end = gen_reg_rtx (Pmode);
3669           if (target == 0)
3670             target = end;
3671         }
3672       else
3673         end = target;
3674     }
3675
3676   data = insn_data + CODE_FOR_movstr;
3677
3678   if (data->operand[0].mode != VOIDmode)
3679     end = gen_lowpart (data->operand[0].mode, end);
3680
3681   insn = data->genfun (end, dest_mem, src_mem);
3682
3683   gcc_assert (insn);
3684
3685   emit_insn (insn);
3686
3687   /* movstr is supposed to set end to the address of the NUL
3688      terminator.  If the caller requested a mempcpy-like return value,
3689      adjust it.  */
3690   if (endp == 1 && target != const0_rtx)
3691     {
3692       rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3693       emit_move_insn (target, force_operand (tem, NULL_RTX));
3694     }
3695
3696   return target;
3697 }
3698
3699 /* Expand expression EXP, which is a call to the strcpy builtin.  Return
3700    NULL_RTX if we failed the caller should emit a normal call, otherwise
3701    try to get the result in TARGET, if convenient (and in mode MODE if that's
3702    convenient).  */
3703
3704 static rtx
3705 expand_builtin_strcpy (tree fndecl, tree exp, rtx target, enum machine_mode mode)
3706 {
3707   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3708    {
3709      tree dest = CALL_EXPR_ARG (exp, 0);
3710      tree src = CALL_EXPR_ARG (exp, 1);
3711      return expand_builtin_strcpy_args (fndecl, dest, src, target, mode);
3712    }
3713    return NULL_RTX;
3714 }
3715
3716 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3717    arguments to the builtin_strcpy call DEST and SRC are broken out
3718    so that this can also be called without constructing an actual CALL_EXPR.
3719    The other arguments and return value are the same as for
3720    expand_builtin_strcpy.  */
3721
3722 static rtx
3723 expand_builtin_strcpy_args (tree fndecl, tree dest, tree src,
3724                             rtx target, enum machine_mode mode)
3725 {
3726   tree result = fold_builtin_strcpy (fndecl, dest, src, 0);
3727   if (result)
3728     return expand_expr (result, target, mode, EXPAND_NORMAL);
3729   return expand_movstr (dest, src, target, /*endp=*/0);
3730
3731 }
3732
3733 /* Expand a call EXP to the stpcpy builtin.
3734    Return NULL_RTX if we failed the caller should emit a normal call,
3735    otherwise try to get the result in TARGET, if convenient (and in
3736    mode MODE if that's convenient).  */
3737
3738 static rtx
3739 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3740 {
3741   tree dst, src;
3742
3743   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3744     return NULL_RTX;
3745
3746   dst = CALL_EXPR_ARG (exp, 0);
3747   src = CALL_EXPR_ARG (exp, 1);
3748
3749   /* If return value is ignored, transform stpcpy into strcpy.  */
3750   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3751     {
3752       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3753       tree result = build_call_expr (fn, 2, dst, src);
3754
3755       STRIP_NOPS (result);
3756       while (TREE_CODE (result) == COMPOUND_EXPR)
3757         {
3758           expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3759                        EXPAND_NORMAL);
3760           result = TREE_OPERAND (result, 1);
3761         }
3762       return expand_expr (result, target, mode, EXPAND_NORMAL);
3763     }
3764   else
3765     {
3766       tree len, lenp1;
3767       rtx ret;
3768
3769       /* Ensure we get an actual string whose length can be evaluated at
3770          compile-time, not an expression containing a string.  This is
3771          because the latter will potentially produce pessimized code
3772          when used to produce the return value.  */
3773       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3774         return expand_movstr (dst, src, target, /*endp=*/2);
3775
3776       lenp1 = size_binop (PLUS_EXPR, len, ssize_int (1));
3777       ret = expand_builtin_mempcpy_args (dst, src, lenp1, TREE_TYPE (exp),
3778                                          target, mode, /*endp=*/2);
3779
3780       if (ret)
3781         return ret;
3782
3783       if (TREE_CODE (len) == INTEGER_CST)
3784         {
3785           rtx len_rtx = expand_normal (len);
3786
3787           if (GET_CODE (len_rtx) == CONST_INT)
3788             {
3789               ret = expand_builtin_strcpy_args (get_callee_fndecl (exp),
3790                                                 dst, src, target, mode);
3791
3792               if (ret)
3793                 {
3794                   if (! target)
3795                     {
3796                       if (mode != VOIDmode)
3797                         target = gen_reg_rtx (mode);
3798                       else
3799                         target = gen_reg_rtx (GET_MODE (ret));
3800                     }
3801                   if (GET_MODE (target) != GET_MODE (ret))
3802                     ret = gen_lowpart (GET_MODE (target), ret);
3803
3804                   ret = plus_constant (ret, INTVAL (len_rtx));
3805                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3806                   gcc_assert (ret);
3807
3808                   return target;
3809                 }
3810             }
3811         }
3812
3813       return expand_movstr (dst, src, target, /*endp=*/2);
3814     }
3815 }
3816
3817 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3818    bytes from constant string DATA + OFFSET and return it as target
3819    constant.  */
3820
3821 rtx
3822 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3823                           enum machine_mode mode)
3824 {
3825   const char *str = (const char *) data;
3826
3827   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3828     return const0_rtx;
3829
3830   return c_readstr (str + offset, mode);
3831 }
3832
3833 /* Expand expression EXP, which is a call to the strncpy builtin.  Return
3834    NULL_RTX if we failed the caller should emit a normal call.  */
3835
3836 static rtx
3837 expand_builtin_strncpy (tree exp, rtx target, enum machine_mode mode)
3838 {
3839   tree fndecl = get_callee_fndecl (exp);
3840
3841   if (validate_arglist (exp,
3842                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3843     {
3844       tree dest = CALL_EXPR_ARG (exp, 0);
3845       tree src = CALL_EXPR_ARG (exp, 1);
3846       tree len = CALL_EXPR_ARG (exp, 2);
3847       tree slen = c_strlen (src, 1);
3848       tree result = fold_builtin_strncpy (fndecl, dest, src, len, slen);
3849
3850       if (result)
3851         {
3852           while (TREE_CODE (result) == COMPOUND_EXPR)
3853             {
3854               expand_expr (TREE_OPERAND (result, 0), const0_rtx, VOIDmode,
3855                            EXPAND_NORMAL);
3856               result = TREE_OPERAND (result, 1);
3857             }
3858           return expand_expr (result, target, mode, EXPAND_NORMAL);
3859         }
3860
3861       /* We must be passed a constant len and src parameter.  */
3862       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3863         return NULL_RTX;
3864
3865       slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
3866
3867       /* We're required to pad with trailing zeros if the requested
3868          len is greater than strlen(s2)+1.  In that case try to
3869          use store_by_pieces, if it fails, punt.  */
3870       if (tree_int_cst_lt (slen, len))
3871         {
3872           unsigned int dest_align
3873             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3874           const char *p = c_getstr (src);
3875           rtx dest_mem;
3876
3877           if (!p || dest_align == 0 || !host_integerp (len, 1)
3878               || !can_store_by_pieces (tree_low_cst (len, 1),
3879                                        builtin_strncpy_read_str,
3880                                        CONST_CAST (char *, p),
3881                                        dest_align, false))
3882             return NULL_RTX;
3883
3884           dest_mem = get_memory_rtx (dest, len);
3885           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3886                            builtin_strncpy_read_str,
3887                            CONST_CAST (char *, p), dest_align, false, 0);
3888           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3889           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3890           return dest_mem;
3891         }
3892     }
3893   return NULL_RTX;
3894 }
3895
3896 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3897    bytes from constant string DATA + OFFSET and return it as target
3898    constant.  */
3899
3900 rtx
3901 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3902                          enum machine_mode mode)
3903 {
3904   const char *c = (const char *) data;
3905   char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3906
3907   memset (p, *c, GET_MODE_SIZE (mode));
3908
3909   return c_readstr (p, mode);
3910 }
3911
3912 /* Callback routine for store_by_pieces.  Return the RTL of a register
3913    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3914    char value given in the RTL register data.  For example, if mode is
3915    4 bytes wide, return the RTL for 0x01010101*data.  */
3916
3917 static rtx
3918 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3919                         enum machine_mode mode)
3920 {
3921   rtx target, coeff;
3922   size_t size;
3923   char *p;
3924
3925   size = GET_MODE_SIZE (mode);
3926   if (size == 1)
3927     return (rtx) data;
3928
3929   p = XALLOCAVEC (char, size);
3930   memset (p, 1, size);
3931   coeff = c_readstr (p, mode);
3932
3933   target = convert_to_mode (mode, (rtx) data, 1);
3934   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3935   return force_reg (mode, target);
3936 }
3937
3938 /* Expand expression EXP, which is a call to the memset builtin.  Return
3939    NULL_RTX if we failed the caller should emit a normal call, otherwise
3940    try to get the result in TARGET, if convenient (and in mode MODE if that's
3941    convenient).  */
3942
3943 static rtx
3944 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3945 {
3946   if (!validate_arglist (exp,
3947                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3948     return NULL_RTX;
3949   else
3950     {
3951       tree dest = CALL_EXPR_ARG (exp, 0);
3952       tree val = CALL_EXPR_ARG (exp, 1);
3953       tree len = CALL_EXPR_ARG (exp, 2);
3954       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3955     }
3956 }
3957
3958 /* Helper function to do the actual work for expand_builtin_memset.  The
3959    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3960    so that this can also be called without constructing an actual CALL_EXPR.
3961    The other arguments and return value are the same as for
3962    expand_builtin_memset.  */
3963
3964 static rtx
3965 expand_builtin_memset_args (tree dest, tree val, tree len,
3966                             rtx target, enum machine_mode mode, tree orig_exp)
3967 {
3968   tree fndecl, fn;
3969   enum built_in_function fcode;
3970   char c;
3971   unsigned int dest_align;
3972   rtx dest_mem, dest_addr, len_rtx;
3973   HOST_WIDE_INT expected_size = -1;
3974   unsigned int expected_align = 0;
3975   tree_ann_common_t ann;
3976
3977   dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3978
3979   /* If DEST is not a pointer type, don't do this operation in-line.  */
3980   if (dest_align == 0)
3981     return NULL_RTX;
3982
3983   ann = tree_common_ann (orig_exp);
3984   if (ann)
3985     stringop_block_profile (ann->stmt, &expected_align, &expected_size);
3986
3987   if (expected_align < dest_align)
3988     expected_align = dest_align;
3989
3990   /* If the LEN parameter is zero, return DEST.  */
3991   if (integer_zerop (len))
3992     {
3993       /* Evaluate and ignore VAL in case it has side-effects.  */
3994       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3995       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3996     }
3997
3998   /* Stabilize the arguments in case we fail.  */
3999   dest = builtin_save_expr (dest);
4000   val = builtin_save_expr (val);
4001   len = builtin_save_expr (len);
4002
4003   len_rtx = expand_normal (len);
4004   dest_mem = get_memory_rtx (dest, len);
4005
4006   if (TREE_CODE (val) != INTEGER_CST)
4007     {
4008       rtx val_rtx;
4009
4010       val_rtx = expand_normal (val);
4011       val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
4012                                  val_rtx, 0);
4013
4014       /* Assume that we can memset by pieces if we can store
4015        * the coefficients by pieces (in the required modes).
4016        * We can't pass builtin_memset_gen_str as that emits RTL.  */
4017       c = 1;
4018       if (host_integerp (len, 1)
4019           && can_store_by_pieces (tree_low_cst (len, 1),
4020                                   builtin_memset_read_str, &c, dest_align,
4021                                   true))
4022         {
4023           val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
4024                                val_rtx);
4025           store_by_pieces (dest_mem, tree_low_cst (len, 1),
4026                            builtin_memset_gen_str, val_rtx, dest_align,
4027                            true, 0);
4028         }
4029       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
4030                                         dest_align, expected_align,
4031                                         expected_size))
4032         goto do_libcall;
4033
4034       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4035       dest_mem = convert_memory_address (ptr_mode, dest_mem);
4036       return dest_mem;
4037     }
4038
4039   if (target_char_cast (val, &c))
4040     goto do_libcall;
4041
4042   if (c)
4043     {
4044       if (host_integerp (len, 1)
4045           && can_store_by_pieces (tree_low_cst (len, 1),
4046                                   builtin_memset_read_str, &c, dest_align,
4047                                   true))
4048         store_by_pieces (dest_mem, tree_low_cst (len, 1),
4049                          builtin_memset_read_str, &c, dest_align, true, 0);
4050       else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
4051                                         dest_align, expected_align,
4052                                         expected_size))
4053         goto do_libcall;
4054
4055       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4056       dest_mem = convert_memory_address (ptr_mode, dest_mem);
4057       return dest_mem;
4058     }
4059
4060   set_mem_align (dest_mem, dest_align);
4061   dest_addr = clear_storage_hints (dest_mem, len_rtx,
4062                                    CALL_EXPR_TAILCALL (orig_exp)
4063                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
4064                                    expected_align, expected_size);
4065
4066   if (dest_addr == 0)
4067     {
4068       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
4069       dest_addr = convert_memory_address (ptr_mode, dest_addr);
4070     }
4071
4072   return dest_addr;
4073
4074  do_libcall:
4075   fndecl = get_callee_fndecl (orig_exp);
4076   fcode = DECL_FUNCTION_CODE (fndecl);
4077   if (fcode == BUILT_IN_MEMSET)
4078     fn = build_call_expr (fndecl, 3, dest, val, len);
4079   else if (fcode == BUILT_IN_BZERO)
4080     fn = build_call_expr (fndecl, 2, dest, len);
4081   else
4082     gcc_unreachable ();
4083   if (TREE_CODE (fn) == CALL_EXPR)
4084     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
4085   return expand_call (fn, target, target == const0_rtx);
4086 }
4087
4088 /* Expand expression EXP, which is a call to the bzero builtin.  Return
4089    NULL_RTX if we failed the caller should emit a normal call.  */
4090
4091 static rtx
4092 expand_builtin_bzero (tree exp)
4093 {
4094   tree dest, size;
4095
4096   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4097     return NULL_RTX;
4098
4099   dest = CALL_EXPR_ARG (exp, 0);
4100   size = CALL_EXPR_ARG (exp, 1);
4101
4102   /* New argument list transforming bzero(ptr x, int y) to
4103      memset(ptr x, int 0, size_t y).   This is done this way
4104      so that if it isn't expanded inline, we fallback to
4105      calling bzero instead of memset.  */
4106
4107   return expand_builtin_memset_args (dest, integer_zero_node,
4108                                      fold_convert (sizetype, size),
4109                                      const0_rtx, VOIDmode, exp);
4110 }
4111
4112 /* Expand a call to the memchr builtin.  Return NULL_RTX if we failed the
4113    caller should emit a normal call, otherwise try to get the result
4114    in TARGET, if convenient (and in mode MODE if that's convenient).  */
4115
4116 static rtx
4117 expand_builtin_memchr (tree exp, rtx target, enum machine_mode mode)
4118 {
4119   if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE,
4120                         INTEGER_TYPE, VOID_TYPE))
4121     {
4122       tree type = TREE_TYPE (exp);
4123       tree result = fold_builtin_memchr (CALL_EXPR_ARG (exp, 0),
4124                                          CALL_EXPR_ARG (exp, 1),
4125                                          CALL_EXPR_ARG (exp, 2), type);
4126       if (result)
4127         return expand_expr (result, target, mode, EXPAND_NORMAL);
4128     }
4129   return NULL_RTX;
4130 }
4131
4132 /* Expand expression EXP, which is a call to the memcmp built-in function.
4133    Return NULL_RTX if we failed and the
4134    caller should emit a normal call, otherwise try to get the result in
4135    TARGET, if convenient (and in mode MODE, if that's convenient).  */
4136
4137 static rtx
4138 expand_builtin_memcmp (tree exp, rtx target, enum machine_mode mode)
4139 {
4140   if (!validate_arglist (exp,
4141                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4142     return NULL_RTX;
4143   else
4144     {
4145       tree result = fold_builtin_memcmp (CALL_EXPR_ARG (exp, 0),
4146                                          CALL_EXPR_ARG (exp, 1),
4147                                          CALL_EXPR_ARG (exp, 2));
4148       if (result)
4149         return expand_expr (result, target, mode, EXPAND_NORMAL);
4150     }
4151
4152 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4153   {
4154     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4155     rtx result;
4156     rtx insn;
4157     tree arg1 = CALL_EXPR_ARG (exp, 0);
4158     tree arg2 = CALL_EXPR_ARG (exp, 1);
4159     tree len = CALL_EXPR_ARG (exp, 2);
4160
4161     int arg1_align
4162       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4163     int arg2_align
4164       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4165     enum machine_mode insn_mode;
4166
4167 #ifdef HAVE_cmpmemsi
4168     if (HAVE_cmpmemsi)
4169       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
4170     else
4171 #endif
4172 #ifdef HAVE_cmpstrnsi
4173     if (HAVE_cmpstrnsi)
4174       insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4175     else
4176 #endif
4177       return NULL_RTX;
4178
4179     /* If we don't have POINTER_TYPE, call the function.  */
4180     if (arg1_align == 0 || arg2_align == 0)
4181       return NULL_RTX;
4182
4183     /* Make a place to write the result of the instruction.  */
4184     result = target;
4185     if (! (result != 0
4186            && REG_P (result) && GET_MODE (result) == insn_mode
4187            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4188       result = gen_reg_rtx (insn_mode);
4189
4190     arg1_rtx = get_memory_rtx (arg1, len);
4191     arg2_rtx = get_memory_rtx (arg2, len);
4192     arg3_rtx = expand_normal (fold_convert (sizetype, len));
4193
4194     /* Set MEM_SIZE as appropriate.  */
4195     if (GET_CODE (arg3_rtx) == CONST_INT)
4196       {
4197         set_mem_size (arg1_rtx, arg3_rtx);
4198         set_mem_size (arg2_rtx, arg3_rtx);
4199       }
4200
4201 #ifdef HAVE_cmpmemsi
4202     if (HAVE_cmpmemsi)
4203       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4204                            GEN_INT (MIN (arg1_align, arg2_align)));
4205     else
4206 #endif
4207 #ifdef HAVE_cmpstrnsi
4208     if (HAVE_cmpstrnsi)
4209       insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4210                             GEN_INT (MIN (arg1_align, arg2_align)));
4211     else
4212 #endif
4213       gcc_unreachable ();
4214
4215     if (insn)
4216       emit_insn (insn);
4217     else
4218       emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
4219                                TYPE_MODE (integer_type_node), 3,
4220                                XEXP (arg1_rtx, 0), Pmode,
4221                                XEXP (arg2_rtx, 0), Pmode,
4222                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
4223                                                 TYPE_UNSIGNED (sizetype)),
4224                                TYPE_MODE (sizetype));
4225
4226     /* Return the value in the proper mode for this function.  */
4227     mode = TYPE_MODE (TREE_TYPE (exp));
4228     if (GET_MODE (result) == mode)
4229       return result;
4230     else if (target != 0)
4231       {
4232         convert_move (target, result, 0);
4233         return target;
4234       }
4235     else
4236       return convert_to_mode (mode, result, 0);
4237   }
4238 #endif
4239
4240   return NULL_RTX;
4241 }
4242
4243 /* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
4244    if we failed the caller should emit a normal call, otherwise try to get
4245    the result in TARGET, if convenient.  */
4246
4247 static rtx
4248 expand_builtin_strcmp (tree exp, rtx target, enum machine_mode mode)
4249 {
4250   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4251     return NULL_RTX;
4252   else
4253     {
4254       tree result = fold_builtin_strcmp (CALL_EXPR_ARG (exp, 0),
4255                                          CALL_EXPR_ARG (exp, 1));
4256       if (result)
4257         return expand_expr (result, target, mode, EXPAND_NORMAL);
4258     }
4259
4260 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4261   if (cmpstr_optab[SImode] != CODE_FOR_nothing
4262       || cmpstrn_optab[SImode] != CODE_FOR_nothing)
4263     {
4264       rtx arg1_rtx, arg2_rtx;
4265       rtx result, insn = NULL_RTX;
4266       tree fndecl, fn;
4267       tree arg1 = CALL_EXPR_ARG (exp, 0);
4268       tree arg2 = CALL_EXPR_ARG (exp, 1);
4269
4270       int arg1_align
4271         = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4272       int arg2_align
4273         = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4274
4275       /* If we don't have POINTER_TYPE, call the function.  */
4276       if (arg1_align == 0 || arg2_align == 0)
4277         return NULL_RTX;
4278
4279       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
4280       arg1 = builtin_save_expr (arg1);
4281       arg2 = builtin_save_expr (arg2);
4282
4283       arg1_rtx = get_memory_rtx (arg1, NULL);
4284       arg2_rtx = get_memory_rtx (arg2, NULL);
4285
4286 #ifdef HAVE_cmpstrsi
4287       /* Try to call cmpstrsi.  */
4288       if (HAVE_cmpstrsi)
4289         {
4290           enum machine_mode insn_mode
4291             = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4292
4293           /* Make a place to write the result of the instruction.  */
4294           result = target;
4295           if (! (result != 0
4296                  && REG_P (result) && GET_MODE (result) == insn_mode
4297                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4298             result = gen_reg_rtx (insn_mode);
4299
4300           insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4301                                GEN_INT (MIN (arg1_align, arg2_align)));
4302         }
4303 #endif
4304 #ifdef HAVE_cmpstrnsi
4305       /* Try to determine at least one length and call cmpstrnsi.  */
4306       if (!insn && HAVE_cmpstrnsi)
4307         {
4308           tree len;
4309           rtx arg3_rtx;
4310
4311           enum machine_mode insn_mode
4312             = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4313           tree len1 = c_strlen (arg1, 1);
4314           tree len2 = c_strlen (arg2, 1);
4315
4316           if (len1)
4317             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4318           if (len2)
4319             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4320
4321           /* If we don't have a constant length for the first, use the length
4322              of the second, if we know it.  We don't require a constant for
4323              this case; some cost analysis could be done if both are available
4324              but neither is constant.  For now, assume they're equally cheap,
4325              unless one has side effects.  If both strings have constant lengths,
4326              use the smaller.  */
4327
4328           if (!len1)
4329             len = len2;
4330           else if (!len2)
4331             len = len1;
4332           else if (TREE_SIDE_EFFECTS (len1))
4333             len = len2;
4334           else if (TREE_SIDE_EFFECTS (len2))
4335             len = len1;
4336           else if (TREE_CODE (len1) != INTEGER_CST)
4337             len = len2;
4338           else if (TREE_CODE (len2) != INTEGER_CST)
4339             len = len1;
4340           else if (tree_int_cst_lt (len1, len2))
4341             len = len1;
4342           else
4343             len = len2;
4344
4345           /* If both arguments have side effects, we cannot optimize.  */
4346           if (!len || TREE_SIDE_EFFECTS (len))
4347             goto do_libcall;
4348
4349           arg3_rtx = expand_normal (len);
4350
4351           /* Make a place to write the result of the instruction.  */
4352           result = target;
4353           if (! (result != 0
4354                  && REG_P (result) && GET_MODE (result) == insn_mode
4355                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4356             result = gen_reg_rtx (insn_mode);
4357
4358           insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4359                                 GEN_INT (MIN (arg1_align, arg2_align)));
4360         }
4361 #endif
4362
4363       if (insn)
4364         {
4365           emit_insn (insn);
4366
4367           /* Return the value in the proper mode for this function.  */
4368           mode = TYPE_MODE (TREE_TYPE (exp));
4369           if (GET_MODE (result) == mode)
4370             return result;
4371           if (target == 0)
4372             return convert_to_mode (mode, result, 0);
4373           convert_move (target, result, 0);
4374           return target;
4375         }
4376
4377       /* Expand the library call ourselves using a stabilized argument
4378          list to avoid re-evaluating the function's arguments twice.  */
4379 #ifdef HAVE_cmpstrnsi
4380     do_libcall:
4381 #endif
4382       fndecl = get_callee_fndecl (exp);
4383       fn = build_call_expr (fndecl, 2, arg1, arg2);
4384       if (TREE_CODE (fn) == CALL_EXPR)
4385         CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4386       return expand_call (fn, target, target == const0_rtx);
4387     }
4388 #endif
4389   return NULL_RTX;
4390 }
4391
4392 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4393    NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4394    the result in TARGET, if convenient.  */
4395
4396 static rtx
4397 expand_builtin_strncmp (tree exp, rtx target, enum machine_mode mode)
4398 {
4399   if (!validate_arglist (exp,
4400                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4401     return NULL_RTX;
4402   else
4403     {
4404       tree result = fold_builtin_strncmp (CALL_EXPR_ARG (exp, 0),
4405                                           CALL_EXPR_ARG (exp, 1),
4406                                           CALL_EXPR_ARG (exp, 2));
4407       if (result)
4408         return expand_expr (result, target, mode, EXPAND_NORMAL);
4409     }
4410
4411   /* If c_strlen can determine an expression for one of the string
4412      lengths, and it doesn't have side effects, then emit cmpstrnsi
4413      using length MIN(strlen(string)+1, arg3).  */
4414 #ifdef HAVE_cmpstrnsi
4415   if (HAVE_cmpstrnsi)
4416   {
4417     tree len, len1, len2;
4418     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4419     rtx result, insn;
4420     tree fndecl, fn;
4421     tree arg1 = CALL_EXPR_ARG (exp, 0);
4422     tree arg2 = CALL_EXPR_ARG (exp, 1);
4423     tree arg3 = CALL_EXPR_ARG (exp, 2);
4424
4425     int arg1_align
4426       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4427     int arg2_align
4428       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4429     enum machine_mode insn_mode
4430       = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4431
4432     len1 = c_strlen (arg1, 1);
4433     len2 = c_strlen (arg2, 1);
4434
4435     if (len1)
4436       len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4437     if (len2)
4438       len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4439
4440     /* If we don't have a constant length for the first, use the length
4441        of the second, if we know it.  We don't require a constant for
4442        this case; some cost analysis could be done if both are available
4443        but neither is constant.  For now, assume they're equally cheap,
4444        unless one has side effects.  If both strings have constant lengths,
4445        use the smaller.  */
4446
4447     if (!len1)
4448       len = len2;
4449     else if (!len2)
4450       len = len1;
4451     else if (TREE_SIDE_EFFECTS (len1))
4452       len = len2;
4453     else if (TREE_SIDE_EFFECTS (len2))
4454       len = len1;
4455     else if (TREE_CODE (len1) != INTEGER_CST)
4456       len = len2;
4457     else if (TREE_CODE (len2) != INTEGER_CST)
4458       len = len1;
4459     else if (tree_int_cst_lt (len1, len2))
4460       len = len1;
4461     else
4462       len = len2;
4463
4464     /* If both arguments have side effects, we cannot optimize.  */
4465     if (!len || TREE_SIDE_EFFECTS (len))
4466       return NULL_RTX;
4467
4468     /* The actual new length parameter is MIN(len,arg3).  */
4469     len = fold_build2 (MIN_EXPR, TREE_TYPE (len), len,
4470                        fold_convert (TREE_TYPE (len), arg3));
4471
4472     /* If we don't have POINTER_TYPE, call the function.  */
4473     if (arg1_align == 0 || arg2_align == 0)
4474       return NULL_RTX;
4475
4476     /* Make a place to write the result of the instruction.  */
4477     result = target;
4478     if (! (result != 0
4479            && REG_P (result) && GET_MODE (result) == insn_mode
4480            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4481       result = gen_reg_rtx (insn_mode);
4482
4483     /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
4484     arg1 = builtin_save_expr (arg1);
4485     arg2 = builtin_save_expr (arg2);
4486     len = builtin_save_expr (len);
4487
4488     arg1_rtx = get_memory_rtx (arg1, len);
4489     arg2_rtx = get_memory_rtx (arg2, len);
4490     arg3_rtx = expand_normal (len);
4491     insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4492                           GEN_INT (MIN (arg1_align, arg2_align)));
4493     if (insn)
4494       {
4495         emit_insn (insn);
4496
4497         /* Return the value in the proper mode for this function.  */
4498         mode = TYPE_MODE (TREE_TYPE (exp));
4499         if (GET_MODE (result) == mode)
4500           return result;
4501         if (target == 0)
4502           return convert_to_mode (mode, result, 0);
4503         convert_move (target, result, 0);
4504         return target;
4505       }
4506
4507     /* Expand the library call ourselves using a stabilized argument
4508        list to avoid re-evaluating the function's arguments twice.  */
4509     fndecl = get_callee_fndecl (exp);
4510     fn = build_call_expr (fndecl, 3, arg1, arg2, len);
4511     if (TREE_CODE (fn) == CALL_EXPR)
4512       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4513     return expand_call (fn, target, target == const0_rtx);
4514   }
4515 #endif
4516   return NULL_RTX;
4517 }
4518
4519 /* Expand expression EXP, which is a call to the strcat builtin.
4520    Return NULL_RTX if we failed the caller should emit a normal call,
4521    otherwise try to get the result in TARGET, if convenient.  */
4522
4523 static rtx
4524 expand_builtin_strcat (tree fndecl, tree exp, rtx target, enum machine_mode mode)
4525 {
4526   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4527     return NULL_RTX;
4528   else
4529     {
4530       tree dst = CALL_EXPR_ARG (exp, 0);
4531       tree src = CALL_EXPR_ARG (exp, 1);
4532       const char *p = c_getstr (src);
4533
4534       /* If the string length is zero, return the dst parameter.  */
4535       if (p && *p == '\0')
4536         return expand_expr (dst, target, mode, EXPAND_NORMAL);
4537
4538       if (optimize_insn_for_speed_p ())
4539         {
4540           /* See if we can store by pieces into (dst + strlen(dst)).  */
4541           tree newsrc, newdst,
4542             strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
4543           rtx insns;
4544
4545           /* Stabilize the argument list.  */
4546           newsrc = builtin_save_expr (src);
4547           dst = builtin_save_expr (dst);
4548
4549           start_sequence ();
4550
4551           /* Create strlen (dst).  */
4552           newdst = build_call_expr (strlen_fn, 1, dst);
4553           /* Create (dst p+ strlen (dst)).  */
4554
4555           newdst = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dst), dst, newdst);
4556           newdst = builtin_save_expr (newdst);
4557
4558           if (!expand_builtin_strcpy_args (fndecl, newdst, newsrc, target, mode))
4559             {
4560               end_sequence (); /* Stop sequence.  */
4561               return NULL_RTX;
4562             }
4563
4564           /* Output the entire sequence.  */
4565           insns = get_insns ();
4566           end_sequence ();
4567           emit_insn (insns);
4568
4569           return expand_expr (dst, target, mode, EXPAND_NORMAL);
4570         }
4571
4572       return NULL_RTX;
4573     }
4574 }
4575
4576 /* Expand expression EXP, which is a call to the strncat builtin.
4577    Return NULL_RTX if we failed the caller should emit a normal call,
4578    otherwise try to get the result in TARGET, if convenient.  */
4579
4580 static rtx
4581 expand_builtin_strncat (tree exp, rtx target, enum machine_mode mode)
4582 {
4583   if (validate_arglist (exp,
4584                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4585     {
4586       tree result = fold_builtin_strncat (CALL_EXPR_ARG (exp, 0),
4587                                           CALL_EXPR_ARG (exp, 1),
4588                                           CALL_EXPR_ARG (exp, 2));
4589       if (result)
4590         return expand_expr (result, target, mode, EXPAND_NORMAL);
4591     }
4592   return NULL_RTX;
4593 }
4594
4595 /* Expand expression EXP, which is a call to the strspn builtin.
4596    Return NULL_RTX if we failed the caller should emit a normal call,
4597    otherwise try to get the result in TARGET, if convenient.  */
4598
4599 static rtx
4600 expand_builtin_strspn (tree exp, rtx target, enum machine_mode mode)
4601 {
4602   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4603     {
4604       tree result = fold_builtin_strspn (CALL_EXPR_ARG (exp, 0),
4605                                          CALL_EXPR_ARG (exp, 1));
4606       if (result)
4607         return expand_expr (result, target, mode, EXPAND_NORMAL);
4608     }
4609   return NULL_RTX;
4610 }
4611
4612 /* Expand expression EXP, which is a call to the strcspn builtin.
4613    Return NULL_RTX if we failed the caller should emit a normal call,
4614    otherwise try to get the result in TARGET, if convenient.  */
4615
4616 static rtx
4617 expand_builtin_strcspn (tree exp, rtx target, enum machine_mode mode)
4618 {
4619   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4620     {
4621       tree result = fold_builtin_strcspn (CALL_EXPR_ARG (exp, 0),
4622                                           CALL_EXPR_ARG (exp, 1));
4623       if (result)
4624         return expand_expr (result, target, mode, EXPAND_NORMAL);
4625     }
4626   return NULL_RTX;
4627 }
4628
4629 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4630    if that's convenient.  */
4631
4632 rtx
4633 expand_builtin_saveregs (void)
4634 {
4635   rtx val, seq;
4636
4637   /* Don't do __builtin_saveregs more than once in a function.
4638      Save the result of the first call and reuse it.  */
4639   if (saveregs_value != 0)
4640     return saveregs_value;
4641
4642   /* When this function is called, it means that registers must be
4643      saved on entry to this function.  So we migrate the call to the
4644      first insn of this function.  */
4645
4646   start_sequence ();
4647
4648   /* Do whatever the machine needs done in this case.  */
4649   val = targetm.calls.expand_builtin_saveregs ();
4650
4651   seq = get_insns ();
4652   end_sequence ();
4653
4654   saveregs_value = val;
4655
4656   /* Put the insns after the NOTE that starts the function.  If this
4657      is inside a start_sequence, make the outer-level insn chain current, so
4658      the code is placed at the start of the function.  */
4659   push_topmost_sequence ();
4660   emit_insn_after (seq, entry_of_function ());
4661   pop_topmost_sequence ();
4662
4663   return val;
4664 }
4665
4666 /* __builtin_args_info (N) returns word N of the arg space info
4667    for the current function.  The number and meanings of words
4668    is controlled by the definition of CUMULATIVE_ARGS.  */
4669
4670 static rtx
4671 expand_builtin_args_info (tree exp)
4672 {
4673   int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
4674   int *word_ptr = (int *) &crtl->args.info;
4675
4676   gcc_assert (sizeof (CUMULATIVE_ARGS) % sizeof (int) == 0);
4677
4678   if (call_expr_nargs (exp) != 0)
4679     {
4680       if (!host_integerp (CALL_EXPR_ARG (exp, 0), 0))
4681         error ("argument of %<__builtin_args_info%> must be constant");
4682       else
4683         {
4684           HOST_WIDE_INT wordnum = tree_low_cst (CALL_EXPR_ARG (exp, 0), 0);
4685
4686           if (wordnum < 0 || wordnum >= nwords)
4687             error ("argument of %<__builtin_args_info%> out of range");
4688           else
4689             return GEN_INT (word_ptr[wordnum]);
4690         }
4691     }
4692   else
4693     error ("missing argument in %<__builtin_args_info%>");
4694
4695   return const0_rtx;
4696 }
4697
4698 /* Expand a call to __builtin_next_arg.  */
4699
4700 static rtx
4701 expand_builtin_next_arg (void)
4702 {
4703   /* Checking arguments is already done in fold_builtin_next_arg
4704      that must be called before this function.  */
4705   return expand_binop (ptr_mode, add_optab,
4706                        crtl->args.internal_arg_pointer,
4707                        crtl->args.arg_offset_rtx,
4708                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
4709 }
4710
4711 /* Make it easier for the backends by protecting the valist argument
4712    from multiple evaluations.  */
4713
4714 static tree
4715 stabilize_va_list (tree valist, int needs_lvalue)
4716 {
4717   tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4718
4719   gcc_assert (vatype != NULL_TREE);
4720
4721   if (TREE_CODE (vatype) == ARRAY_TYPE)
4722     {
4723       if (TREE_SIDE_EFFECTS (valist))
4724         valist = save_expr (valist);
4725
4726       /* For this case, the backends will be expecting a pointer to
4727          vatype, but it's possible we've actually been given an array
4728          (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4729          So fix it.  */
4730       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4731         {
4732           tree p1 = build_pointer_type (TREE_TYPE (vatype));
4733           valist = build_fold_addr_expr_with_type (valist, p1);
4734         }
4735     }
4736   else
4737     {
4738       tree pt;
4739
4740       if (! needs_lvalue)
4741         {
4742           if (! TREE_SIDE_EFFECTS (valist))
4743             return valist;
4744
4745           pt = build_pointer_type (vatype);
4746           valist = fold_build1 (ADDR_EXPR, pt, valist);
4747           TREE_SIDE_EFFECTS (valist) = 1;
4748         }
4749
4750       if (TREE_SIDE_EFFECTS (valist))
4751         valist = save_expr (valist);
4752       valist = build_fold_indirect_ref (valist);
4753     }
4754
4755   return valist;
4756 }
4757
4758 /* The "standard" definition of va_list is void*.  */
4759
4760 tree
4761 std_build_builtin_va_list (void)
4762 {
4763   return ptr_type_node;
4764 }
4765
4766 /* The "standard" abi va_list is va_list_type_node.  */
4767
4768 tree
4769 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4770 {
4771   return va_list_type_node;
4772 }
4773
4774 /* The "standard" type of va_list is va_list_type_node.  */
4775
4776 tree
4777 std_canonical_va_list_type (tree type)
4778 {
4779   tree wtype, htype;
4780
4781   if (INDIRECT_REF_P (type))
4782     type = TREE_TYPE (type);
4783   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4784     type = TREE_TYPE (type);
4785   wtype = va_list_type_node;
4786   htype = type;
4787   /* Treat structure va_list types.  */
4788   if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4789     htype = TREE_TYPE (htype);
4790   else if (TREE_CODE (wtype) == ARRAY_TYPE)
4791     {
4792       /* If va_list is an array type, the argument may have decayed
4793          to a pointer type, e.g. by being passed to another function.
4794          In that case, unwrap both types so that we can compare the
4795          underlying records.  */
4796       if (TREE_CODE (htype) == ARRAY_TYPE
4797           || POINTER_TYPE_P (htype))
4798         {
4799           wtype = TREE_TYPE (wtype);
4800           htype = TREE_TYPE (htype);
4801         }
4802     }
4803   if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4804     return va_list_type_node;
4805
4806   return NULL_TREE;
4807 }
4808
4809 /* The "standard" implementation of va_start: just assign `nextarg' to
4810    the variable.  */
4811
4812 void
4813 std_expand_builtin_va_start (tree valist, rtx nextarg)
4814 {
4815   rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4816   convert_move (va_r, nextarg, 0);
4817 }
4818
4819 /* Expand EXP, a call to __builtin_va_start.  */
4820
4821 static rtx
4822 expand_builtin_va_start (tree exp)
4823 {
4824   rtx nextarg;
4825   tree valist;
4826
4827   if (call_expr_nargs (exp) < 2)
4828     {
4829       error ("too few arguments to function %<va_start%>");
4830       return const0_rtx;
4831     }
4832
4833   if (fold_builtin_next_arg (exp, true))
4834     return const0_rtx;
4835
4836   nextarg = expand_builtin_next_arg ();
4837   valist = stabilize_va_list (CALL_EXPR_ARG (exp, 0), 1);
4838
4839   if (targetm.expand_builtin_va_start)
4840     targetm.expand_builtin_va_start (valist, nextarg);
4841   else
4842     std_expand_builtin_va_start (valist, nextarg);
4843
4844   return const0_rtx;
4845 }
4846
4847 /* The "standard" implementation of va_arg: read the value from the
4848    current (padded) address and increment by the (padded) size.  */
4849
4850 tree
4851 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4852                           gimple_seq *post_p)
4853 {
4854   tree addr, t, type_size, rounded_size, valist_tmp;
4855   unsigned HOST_WIDE_INT align, boundary;
4856   bool indirect;
4857
4858 #ifdef ARGS_GROW_DOWNWARD
4859   /* All of the alignment and movement below is for args-grow-up machines.
4860      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4861      implement their own specialized gimplify_va_arg_expr routines.  */
4862   gcc_unreachable ();
4863 #endif
4864
4865   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4866   if (indirect)
4867     type = build_pointer_type (type);
4868
4869   align = PARM_BOUNDARY / BITS_PER_UNIT;
4870   boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
4871
4872   /* When we align parameter on stack for caller, if the parameter
4873      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4874      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
4875      here with caller.  */
4876   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4877     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4878
4879   boundary /= BITS_PER_UNIT;
4880
4881   /* Hoist the valist value into a temporary for the moment.  */
4882   valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4883
4884   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
4885      requires greater alignment, we must perform dynamic alignment.  */
4886   if (boundary > align
4887       && !integer_zerop (TYPE_SIZE (type)))
4888     {
4889       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4890                   fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist),
4891                                valist_tmp, size_int (boundary - 1)));
4892       gimplify_and_add (t, pre_p);
4893
4894       t = fold_convert (sizetype, valist_tmp);
4895       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4896                   fold_convert (TREE_TYPE (valist),
4897                                 fold_build2 (BIT_AND_EXPR, sizetype, t,
4898                                              size_int (-boundary))));
4899       gimplify_and_add (t, pre_p);
4900     }
4901   else
4902     boundary = align;
4903
4904   /* If the actual alignment is less than the alignment of the type,
4905      adjust the type accordingly so that we don't assume strict alignment
4906      when dereferencing the pointer.  */
4907   boundary *= BITS_PER_UNIT;
4908   if (boundary < TYPE_ALIGN (type))
4909     {
4910       type = build_variant_type_copy (type);
4911       TYPE_ALIGN (type) = boundary;
4912     }
4913
4914   /* Compute the rounded size of the type.  */
4915   type_size = size_in_bytes (type);
4916   rounded_size = round_up (type_size, align);
4917
4918   /* Reduce rounded_size so it's sharable with the postqueue.  */
4919   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4920
4921   /* Get AP.  */
4922   addr = valist_tmp;
4923   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4924     {
4925       /* Small args are padded downward.  */
4926       t = fold_build2 (GT_EXPR, sizetype, rounded_size, size_int (align));
4927       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4928                        size_binop (MINUS_EXPR, rounded_size, type_size));
4929       addr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (addr), addr, t);
4930     }
4931
4932   /* Compute new value for AP.  */
4933   t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist), valist_tmp, rounded_size);
4934   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4935   gimplify_and_add (t, pre_p);
4936
4937   addr = fold_convert (build_pointer_type (type), addr);
4938
4939   if (indirect)
4940     addr = build_va_arg_indirect_ref (addr);
4941
4942   return build_va_arg_indirect_ref (addr);
4943 }
4944
4945 /* Build an indirect-ref expression over the given TREE, which represents a
4946    piece of a va_arg() expansion.  */
4947 tree
4948 build_va_arg_indirect_ref (tree addr)
4949 {
4950   addr = build_fold_indirect_ref (addr);
4951
4952   if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF.  */
4953     mf_mark (addr);
4954
4955   return addr;
4956 }
4957
4958 /* Return a dummy expression of type TYPE in order to keep going after an
4959    error.  */
4960
4961 static tree
4962 dummy_object (tree type)
4963 {
4964   tree t = build_int_cst (build_pointer_type (type), 0);
4965   return build1 (INDIRECT_REF, type, t);
4966 }
4967
4968 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4969    builtin function, but a very special sort of operator.  */
4970
4971 enum gimplify_status
4972 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4973 {
4974   tree promoted_type, have_va_type;
4975   tree valist = TREE_OPERAND (*expr_p, 0);
4976   tree type = TREE_TYPE (*expr_p);
4977   tree t;
4978   location_t loc = EXPR_HAS_LOCATION (*expr_p) ? EXPR_LOCATION (*expr_p) :
4979     UNKNOWN_LOCATION;
4980
4981   /* Verify that valist is of the proper type.  */
4982   have_va_type = TREE_TYPE (valist);
4983   if (have_va_type == error_mark_node)
4984     return GS_ERROR;
4985   have_va_type = targetm.canonical_va_list_type (have_va_type);
4986
4987   if (have_va_type == NULL_TREE)
4988     {
4989       error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4990       return GS_ERROR;
4991     }
4992
4993   /* Generate a diagnostic for requesting data of a type that cannot
4994      be passed through `...' due to type promotion at the call site.  */
4995   if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4996            != type)
4997     {
4998       static bool gave_help;
4999       bool warned;
5000
5001       /* Unfortunately, this is merely undefined, rather than a constraint
5002          violation, so we cannot make this an error.  If this call is never
5003          executed, the program is still strictly conforming.  */
5004       warned = warning_at (loc, 0,
5005                            "%qT is promoted to %qT when passed through %<...%>",
5006                            type, promoted_type);
5007       if (!gave_help && warned)
5008         {
5009           gave_help = true;
5010           inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
5011                   promoted_type, type);
5012         }
5013
5014       /* We can, however, treat "undefined" any way we please.
5015          Call abort to encourage the user to fix the program.  */
5016       if (warned)
5017         inform (loc, "if this code is reached, the program will abort");
5018       /* Before the abort, allow the evaluation of the va_list
5019          expression to exit or longjmp.  */
5020       gimplify_and_add (valist, pre_p);
5021       t = build_call_expr (implicit_built_in_decls[BUILT_IN_TRAP], 0);
5022       gimplify_and_add (t, pre_p);
5023
5024       /* This is dead code, but go ahead and finish so that the
5025          mode of the result comes out right.  */
5026       *expr_p = dummy_object (type);
5027       return GS_ALL_DONE;
5028     }
5029   else
5030     {
5031       /* Make it easier for the backends by protecting the valist argument
5032          from multiple evaluations.  */
5033       if (TREE_CODE (have_va_type) == ARRAY_TYPE)
5034         {
5035           /* For this case, the backends will be expecting a pointer to
5036              TREE_TYPE (abi), but it's possible we've
5037              actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
5038              So fix it.  */
5039           if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
5040             {
5041               tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
5042               valist = fold_convert (p1, build_fold_addr_expr (valist));
5043             }
5044
5045           gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
5046         }
5047       else
5048         gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
5049
5050       if (!targetm.gimplify_va_arg_expr)
5051         /* FIXME: Once most targets are converted we should merely
5052            assert this is non-null.  */
5053         return GS_ALL_DONE;
5054
5055       *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
5056       return GS_OK;
5057     }
5058 }
5059
5060 /* Expand EXP, a call to __builtin_va_end.  */
5061
5062 static rtx
5063 expand_builtin_va_end (tree exp)
5064 {
5065   tree valist = CALL_EXPR_ARG (exp, 0);
5066
5067   /* Evaluate for side effects, if needed.  I hate macros that don't
5068      do that.  */
5069   if (TREE_SIDE_EFFECTS (valist))
5070     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
5071
5072   return const0_rtx;
5073 }
5074
5075 /* Expand EXP, a call to __builtin_va_copy.  We do this as a
5076    builtin rather than just as an assignment in stdarg.h because of the
5077    nastiness of array-type va_list types.  */
5078
5079 static rtx
5080 expand_builtin_va_copy (tree exp)
5081 {
5082   tree dst, src, t;
5083
5084   dst = CALL_EXPR_ARG (exp, 0);
5085   src = CALL_EXPR_ARG (exp, 1);
5086
5087   dst = stabilize_va_list (dst, 1);
5088   src = stabilize_va_list (src, 0);
5089
5090   gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
5091
5092   if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
5093     {
5094       t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
5095       TREE_SIDE_EFFECTS (t) = 1;
5096       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
5097     }
5098   else
5099     {
5100       rtx dstb, srcb, size;
5101
5102       /* Evaluate to pointers.  */
5103       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
5104       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
5105       size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
5106                   NULL_RTX, VOIDmode, EXPAND_NORMAL);
5107
5108       dstb = convert_memory_address (Pmode, dstb);
5109       srcb = convert_memory_address (Pmode, srcb);
5110
5111       /* "Dereference" to BLKmode memories.  */
5112       dstb = gen_rtx_MEM (BLKmode, dstb);
5113       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
5114       set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
5115       srcb = gen_rtx_MEM (BLKmode, srcb);
5116       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
5117       set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
5118
5119       /* Copy.  */
5120       emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
5121     }
5122
5123   return const0_rtx;
5124 }
5125
5126 /* Expand a call to one of the builtin functions __builtin_frame_address or
5127    __builtin_return_address.  */
5128
5129 static rtx
5130 expand_builtin_frame_address (tree fndecl, tree exp)
5131 {
5132   /* The argument must be a nonnegative integer constant.
5133      It counts the number of frames to scan up the stack.
5134      The value is the return address saved in that frame.  */
5135   if (call_expr_nargs (exp) == 0)
5136     /* Warning about missing arg was already issued.  */
5137     return const0_rtx;
5138   else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
5139     {
5140       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
5141         error ("invalid argument to %<__builtin_frame_address%>");
5142       else
5143         error ("invalid argument to %<__builtin_return_address%>");
5144       return const0_rtx;
5145     }
5146   else
5147     {
5148       rtx tem
5149         = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
5150                                       tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
5151
5152       /* Some ports cannot access arbitrary stack frames.  */
5153       if (tem == NULL)
5154         {
5155           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
5156             warning (0, "unsupported argument to %<__builtin_frame_address%>");
5157           else
5158             warning (0, "unsupported argument to %<__builtin_return_address%>");
5159           return const0_rtx;
5160         }
5161
5162       /* For __builtin_frame_address, return what we've got.  */
5163       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
5164         return tem;
5165
5166       if (!REG_P (tem)
5167           && ! CONSTANT_P (tem))
5168         tem = copy_to_mode_reg (Pmode, tem);
5169       return tem;
5170     }
5171 }
5172
5173 /* Expand EXP, a call to the alloca builtin.  Return NULL_RTX if
5174    we failed and the caller should emit a normal call, otherwise try to get
5175    the result in TARGET, if convenient.  */
5176
5177 static rtx
5178 expand_builtin_alloca (tree exp, rtx target)
5179 {
5180   rtx op0;
5181   rtx result;
5182
5183   /* In -fmudflap-instrumented code, alloca() and __builtin_alloca()
5184      should always expand to function calls.  These can be intercepted
5185      in libmudflap.  */
5186   if (flag_mudflap)
5187     return NULL_RTX;
5188
5189   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5190     return NULL_RTX;
5191
5192   /* Compute the argument.  */
5193   op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
5194
5195   /* Allocate the desired space.  */
5196   result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
5197   result = convert_memory_address (ptr_mode, result);
5198
5199   return result;
5200 }
5201
5202 /* Expand a call to a bswap builtin with argument ARG0.  MODE
5203    is the mode to expand with.  */
5204
5205 static rtx
5206 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
5207 {
5208   enum machine_mode mode;
5209   tree arg;
5210   rtx op0;
5211
5212   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5213     return NULL_RTX;
5214
5215   arg = CALL_EXPR_ARG (exp, 0);
5216   mode = TYPE_MODE (TREE_TYPE (arg));
5217   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5218
5219   target = expand_unop (mode, bswap_optab, op0, target, 1);
5220
5221   gcc_assert (target);
5222
5223   return convert_to_mode (mode, target, 0);
5224 }
5225
5226 /* Expand a call to a unary builtin in EXP.
5227    Return NULL_RTX if a normal call should be emitted rather than expanding the
5228    function in-line.  If convenient, the result should be placed in TARGET.
5229    SUBTARGET may be used as the target for computing one of EXP's operands.  */
5230
5231 static rtx
5232 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
5233                      rtx subtarget, optab op_optab)
5234 {
5235   rtx op0;
5236
5237   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
5238     return NULL_RTX;
5239
5240   /* Compute the argument.  */
5241   op0 = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
5242                      VOIDmode, EXPAND_NORMAL);
5243   /* Compute op, into TARGET if possible.
5244      Set TARGET to wherever the result comes back.  */
5245   target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
5246                         op_optab, op0, target, 1);
5247   gcc_assert (target);
5248
5249   return convert_to_mode (target_mode, target, 0);
5250 }
5251
5252 /* If the string passed to fputs is a constant and is one character
5253    long, we attempt to transform this call into __builtin_fputc().  */
5254
5255 static rtx
5256 expand_builtin_fputs (tree exp, rtx target, bool unlocked)
5257 {
5258   /* Verify the arguments in the original call.  */
5259   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5260     {
5261       tree result = fold_builtin_fputs (CALL_EXPR_ARG (exp, 0),
5262                                         CALL_EXPR_ARG (exp, 1),
5263                                         (target == const0_rtx),
5264                                         unlocked, NULL_TREE);
5265       if (result)
5266         return expand_expr (result, target, VOIDmode, EXPAND_NORMAL);
5267     }
5268   return NULL_RTX;
5269 }
5270
5271 /* Expand a call to __builtin_expect.  We just return our argument
5272    as the builtin_expect semantic should've been already executed by
5273    tree branch prediction pass. */
5274
5275 static rtx
5276 expand_builtin_expect (tree exp, rtx target)
5277 {
5278   tree arg, c;
5279
5280   if (call_expr_nargs (exp) < 2)
5281     return const0_rtx;
5282   arg = CALL_EXPR_ARG (exp, 0);
5283   c = CALL_EXPR_ARG (exp, 1);
5284
5285   target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5286   /* When guessing was done, the hints should be already stripped away.  */
5287   gcc_assert (!flag_guess_branch_prob
5288               || optimize == 0 || errorcount || sorrycount);
5289   return target;
5290 }
5291
5292 void
5293 expand_builtin_trap (void)
5294 {
5295 #ifdef HAVE_trap
5296   if (HAVE_trap)
5297     emit_insn (gen_trap ());
5298   else
5299 #endif
5300     emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
5301   emit_barrier ();
5302 }
5303
5304 /* Expand a call to __builtin_unreachable.  We do nothing except emit
5305    a barrier saying that control flow will not pass here.
5306
5307    It is the responsibility of the program being compiled to ensure
5308    that control flow does never reach __builtin_unreachable.  */
5309 static void
5310 expand_builtin_unreachable (void)
5311 {
5312   emit_barrier ();
5313 }
5314
5315 /* Expand EXP, a call to fabs, fabsf or fabsl.
5316    Return NULL_RTX if a normal call should be emitted rather than expanding
5317    the function inline.  If convenient, the result should be placed
5318    in TARGET.  SUBTARGET may be used as the target for computing
5319    the operand.  */
5320
5321 static rtx
5322 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
5323 {
5324   enum machine_mode mode;
5325   tree arg;
5326   rtx op0;
5327
5328   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5329     return NULL_RTX;
5330
5331   arg = CALL_EXPR_ARG (exp, 0);
5332   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
5333   mode = TYPE_MODE (TREE_TYPE (arg));
5334   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5335   return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
5336 }
5337
5338 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5339    Return NULL is a normal call should be emitted rather than expanding the
5340    function inline.  If convenient, the result should be placed in TARGET.
5341    SUBTARGET may be used as the target for computing the operand.  */
5342
5343 static rtx
5344 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
5345 {
5346   rtx op0, op1;
5347   tree arg;
5348
5349   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
5350     return NULL_RTX;
5351
5352   arg = CALL_EXPR_ARG (exp, 0);
5353   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5354
5355   arg = CALL_EXPR_ARG (exp, 1);
5356   op1 = expand_normal (arg);
5357
5358   return expand_copysign (op0, op1, target);
5359 }
5360
5361 /* Create a new constant string literal and return a char* pointer to it.
5362    The STRING_CST value is the LEN characters at STR.  */
5363 tree
5364 build_string_literal (int len, const char *str)
5365 {
5366   tree t, elem, index, type;
5367
5368   t = build_string (len, str);
5369   elem = build_type_variant (char_type_node, 1, 0);
5370   index = build_index_type (size_int (len - 1));
5371   type = build_array_type (elem, index);
5372   TREE_TYPE (t) = type;
5373   TREE_CONSTANT (t) = 1;
5374   TREE_READONLY (t) = 1;
5375   TREE_STATIC (t) = 1;
5376
5377   type = build_pointer_type (elem);
5378   t = build1 (ADDR_EXPR, type,
5379               build4 (ARRAY_REF, elem,
5380                       t, integer_zero_node, NULL_TREE, NULL_TREE));
5381   return t;
5382 }
5383
5384 /* Expand EXP, a call to printf or printf_unlocked.
5385    Return NULL_RTX if a normal call should be emitted rather than transforming
5386    the function inline.  If convenient, the result should be placed in
5387    TARGET with mode MODE.  UNLOCKED indicates this is a printf_unlocked
5388    call.  */
5389 static rtx
5390 expand_builtin_printf (tree exp, rtx target, enum machine_mode mode,
5391                        bool unlocked)
5392 {
5393   /* If we're using an unlocked function, assume the other unlocked
5394      functions exist explicitly.  */
5395   tree const fn_putchar = unlocked ? built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED]
5396     : implicit_built_in_decls[BUILT_IN_PUTCHAR];
5397   tree const fn_puts = unlocked ? built_in_decls[BUILT_IN_PUTS_UNLOCKED]
5398     : implicit_built_in_decls[BUILT_IN_PUTS];
5399   const char *fmt_str;
5400   tree fn = 0;
5401   tree fmt, arg;
5402   int nargs = call_expr_nargs (exp);
5403
5404   /* If the return value is used, don't do the transformation.  */
5405   if (target != const0_rtx)
5406     return NULL_RTX;
5407
5408   /* Verify the required arguments in the original call.  */
5409   if (nargs == 0)
5410     return NULL_RTX;
5411   fmt = CALL_EXPR_ARG (exp, 0);
5412   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5413     return NULL_RTX;
5414
5415   /* Check whether the format is a literal string constant.  */
5416   fmt_str = c_getstr (fmt);
5417   if (fmt_str == NULL)
5418     return NULL_RTX;
5419
5420   if (!init_target_chars ())
5421     return NULL_RTX;
5422
5423   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
5424   if (strcmp (fmt_str, target_percent_s_newline) == 0)
5425     {
5426       if ((nargs != 2)
5427           || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 1))))
5428         return NULL_RTX;
5429       if (fn_puts)
5430         fn = build_call_expr (fn_puts, 1, CALL_EXPR_ARG (exp, 1));
5431     }
5432   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
5433   else if (strcmp (fmt_str, target_percent_c) == 0)
5434     {
5435       if ((nargs != 2)
5436           || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1))) != INTEGER_TYPE)
5437         return NULL_RTX;
5438       if (fn_putchar)
5439         fn = build_call_expr (fn_putchar, 1, CALL_EXPR_ARG (exp, 1));
5440     }
5441   else
5442     {
5443       /* We can't handle anything else with % args or %% ... yet.  */
5444       if (strchr (fmt_str, target_percent))
5445         return NULL_RTX;
5446
5447       if (nargs > 1)
5448         return NULL_RTX;
5449
5450       /* If the format specifier was "", printf does nothing.  */
5451       if (fmt_str[0] == '\0')
5452         return const0_rtx;
5453       /* If the format specifier has length of 1, call putchar.  */
5454       if (fmt_str[1] == '\0')
5455         {
5456           /* Given printf("c"), (where c is any one character,)
5457              convert "c"[0] to an int and pass that to the replacement
5458              function.  */
5459           arg = build_int_cst (NULL_TREE, fmt_str[0]);
5460           if (fn_putchar)
5461             fn = build_call_expr (fn_putchar, 1, arg);
5462         }
5463       else
5464         {
5465           /* If the format specifier was "string\n", call puts("string").  */
5466           size_t len = strlen (fmt_str);
5467           if ((unsigned char)fmt_str[len - 1] == target_newline)
5468             {
5469               /* Create a NUL-terminated string that's one char shorter
5470                  than the original, stripping off the trailing '\n'.  */
5471               char *newstr = XALLOCAVEC (char, len);
5472               memcpy (newstr, fmt_str, len - 1);
5473               newstr[len - 1] = 0;
5474               arg = build_string_literal (len, newstr);
5475               if (fn_puts)
5476                 fn = build_call_expr (fn_puts, 1, arg);
5477             }
5478           else
5479             /* We'd like to arrange to call fputs(string,stdout) here,
5480                but we need stdout and don't have a way to get it yet.  */
5481             return NULL_RTX;
5482         }
5483     }
5484
5485   if (!fn)
5486     return NULL_RTX;
5487   if (TREE_CODE (fn) == CALL_EXPR)
5488     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5489   return expand_expr (fn, target, mode, EXPAND_NORMAL);
5490 }
5491
5492 /* Expand EXP, a call to fprintf or fprintf_unlocked.
5493    Return NULL_RTX if a normal call should be emitted rather than transforming
5494    the function inline.  If convenient, the result should be placed in
5495    TARGET with mode MODE.  UNLOCKED indicates this is a fprintf_unlocked
5496    call.  */
5497 static rtx
5498 expand_builtin_fprintf (tree exp, rtx target, enum machine_mode mode,
5499                         bool unlocked)
5500 {
5501   /* If we're using an unlocked function, assume the other unlocked
5502      functions exist explicitly.  */
5503   tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
5504     : implicit_built_in_decls[BUILT_IN_FPUTC];
5505   tree const fn_fputs = unlocked ? built_in_decls[BUILT_IN_FPUTS_UNLOCKED]
5506     : implicit_built_in_decls[BUILT_IN_FPUTS];
5507   const char *fmt_str;
5508   tree fn = 0;
5509   tree fmt, fp, arg;
5510   int nargs = call_expr_nargs (exp);
5511
5512   /* If the return value is used, don't do the transformation.  */
5513   if (target != const0_rtx)
5514     return NULL_RTX;
5515
5516   /* Verify the required arguments in the original call.  */
5517   if (nargs < 2)
5518     return NULL_RTX;
5519   fp = CALL_EXPR_ARG (exp, 0);
5520   if (! POINTER_TYPE_P (TREE_TYPE (fp)))
5521     return NULL_RTX;
5522   fmt = CALL_EXPR_ARG (exp, 1);
5523   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5524     return NULL_RTX;
5525
5526   /* Check whether the format is a literal string constant.  */
5527   fmt_str = c_getstr (fmt);
5528   if (fmt_str == NULL)
5529     return NULL_RTX;
5530
5531   if (!init_target_chars ())
5532     return NULL_RTX;
5533
5534   /* If the format specifier was "%s", call __builtin_fputs(arg,fp).  */
5535   if (strcmp (fmt_str, target_percent_s) == 0)
5536     {
5537       if ((nargs != 3)
5538           || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 2))))
5539         return NULL_RTX;
5540       arg = CALL_EXPR_ARG (exp, 2);
5541       if (fn_fputs)
5542         fn = build_call_expr (fn_fputs, 2, arg, fp);
5543     }
5544   /* If the format specifier was "%c", call __builtin_fputc(arg,fp).  */
5545   else if (strcmp (fmt_str, target_percent_c) == 0)
5546     {
5547       if ((nargs != 3)
5548           || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2))) != INTEGER_TYPE)
5549         return NULL_RTX;
5550       arg = CALL_EXPR_ARG (exp, 2);
5551       if (fn_fputc)
5552         fn = build_call_expr (fn_fputc, 2, arg, fp);
5553     }
5554   else
5555     {
5556       /* We can't handle anything else with % args or %% ... yet.  */
5557       if (strchr (fmt_str, target_percent))
5558         return NULL_RTX;
5559
5560       if (nargs > 2)
5561         return NULL_RTX;
5562
5563       /* If the format specifier was "", fprintf does nothing.  */
5564       if (fmt_str[0] == '\0')
5565         {
5566           /* Evaluate and ignore FILE* argument for side-effects.  */
5567           expand_expr (fp, const0_rtx, VOIDmode, EXPAND_NORMAL);
5568           return const0_rtx;
5569         }
5570
5571       /* When "string" doesn't contain %, replace all cases of
5572          fprintf(stream,string) with fputs(string,stream).  The fputs
5573          builtin will take care of special cases like length == 1.  */
5574       if (fn_fputs)
5575         fn = build_call_expr (fn_fputs, 2, fmt, fp);
5576     }
5577
5578   if (!fn)
5579     return NULL_RTX;
5580   if (TREE_CODE (fn) == CALL_EXPR)
5581     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5582   return expand_expr (fn, target, mode, EXPAND_NORMAL);
5583 }
5584
5585 /* Expand a call EXP to sprintf.  Return NULL_RTX if
5586    a normal call should be emitted rather than expanding the function
5587    inline.  If convenient, the result should be placed in TARGET with
5588    mode MODE.  */
5589
5590 static rtx
5591 expand_builtin_sprintf (tree exp, rtx target, enum machine_mode mode)
5592 {
5593   tree dest, fmt;
5594   const char *fmt_str;
5595   int nargs = call_expr_nargs (exp);
5596
5597   /* Verify the required arguments in the original call.  */
5598   if (nargs < 2)
5599     return NULL_RTX;
5600   dest = CALL_EXPR_ARG (exp, 0);
5601   if (! POINTER_TYPE_P (TREE_TYPE (dest)))
5602     return NULL_RTX;
5603   fmt = CALL_EXPR_ARG (exp, 0);
5604   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5605     return NULL_RTX;
5606
5607   /* Check whether the format is a literal string constant.  */
5608   fmt_str = c_getstr (fmt);
5609   if (fmt_str == NULL)
5610     return NULL_RTX;
5611
5612   if (!init_target_chars ())
5613     return NULL_RTX;
5614
5615   /* If the format doesn't contain % args or %%, use strcpy.  */
5616   if (strchr (fmt_str, target_percent) == 0)
5617     {
5618       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5619       tree exp;
5620
5621       if ((nargs > 2) || ! fn)
5622         return NULL_RTX;
5623       expand_expr (build_call_expr (fn, 2, dest, fmt),
5624                    const0_rtx, VOIDmode, EXPAND_NORMAL);
5625       if (target == const0_rtx)
5626         return const0_rtx;
5627       exp = build_int_cst (NULL_TREE, strlen (fmt_str));
5628       return expand_expr (exp, target, mode, EXPAND_NORMAL);
5629     }
5630   /* If the format is "%s", use strcpy if the result isn't used.  */
5631   else if (strcmp (fmt_str, target_percent_s) == 0)
5632     {
5633       tree fn, arg, len;
5634       fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5635
5636       if (! fn)
5637         return NULL_RTX;
5638       if (nargs != 3)
5639         return NULL_RTX;
5640       arg = CALL_EXPR_ARG (exp, 2);
5641       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
5642         return NULL_RTX;
5643
5644       if (target != const0_rtx)
5645         {
5646           len = c_strlen (arg, 1);
5647           if (! len || TREE_CODE (len) != INTEGER_CST)
5648             return NULL_RTX;
5649         }
5650       else
5651         len = NULL_TREE;
5652
5653       expand_expr (build_call_expr (fn, 2, dest, arg),
5654                    const0_rtx, VOIDmode, EXPAND_NORMAL);
5655
5656       if (target == const0_rtx)
5657         return const0_rtx;
5658       return expand_expr (len, target, mode, EXPAND_NORMAL);
5659     }
5660
5661   return NULL_RTX;
5662 }
5663
5664 /* Expand a call to either the entry or exit function profiler.  */
5665
5666 static rtx
5667 expand_builtin_profile_func (bool exitp)
5668 {
5669   rtx this_rtx, which;
5670
5671   this_rtx = DECL_RTL (current_function_decl);
5672   gcc_assert (MEM_P (this_rtx));
5673   this_rtx = XEXP (this_rtx, 0);
5674
5675   if (exitp)
5676     which = profile_function_exit_libfunc;
5677   else
5678     which = profile_function_entry_libfunc;
5679
5680   emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this_rtx, Pmode,
5681                      expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5682                                                  0),
5683                      Pmode);
5684
5685   return const0_rtx;
5686 }
5687
5688 /* Expand a call to __builtin___clear_cache.  */
5689
5690 static rtx
5691 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
5692 {
5693 #ifndef HAVE_clear_cache
5694 #ifdef CLEAR_INSN_CACHE
5695   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5696      does something.  Just do the default expansion to a call to
5697      __clear_cache().  */
5698   return NULL_RTX;
5699 #else
5700   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5701      does nothing.  There is no need to call it.  Do nothing.  */
5702   return const0_rtx;
5703 #endif /* CLEAR_INSN_CACHE */
5704 #else
5705   /* We have a "clear_cache" insn, and it will handle everything.  */
5706   tree begin, end;
5707   rtx begin_rtx, end_rtx;
5708   enum insn_code icode;
5709
5710   /* We must not expand to a library call.  If we did, any
5711      fallback library function in libgcc that might contain a call to
5712      __builtin___clear_cache() would recurse infinitely.  */
5713   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5714     {
5715       error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5716       return const0_rtx;
5717     }
5718
5719   if (HAVE_clear_cache)
5720     {
5721       icode = CODE_FOR_clear_cache;
5722
5723       begin = CALL_EXPR_ARG (exp, 0);
5724       begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
5725       begin_rtx = convert_memory_address (Pmode, begin_rtx);
5726       if (!insn_data[icode].operand[0].predicate (begin_rtx, Pmode))
5727         begin_rtx = copy_to_mode_reg (Pmode, begin_rtx);
5728
5729       end = CALL_EXPR_ARG (exp, 1);
5730       end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
5731       end_rtx = convert_memory_address (Pmode, end_rtx);
5732       if (!insn_data[icode].operand[1].predicate (end_rtx, Pmode))
5733         end_rtx = copy_to_mode_reg (Pmode, end_rtx);
5734
5735       emit_insn (gen_clear_cache (begin_rtx, end_rtx));
5736     }
5737   return const0_rtx;
5738 #endif /* HAVE_clear_cache */
5739 }
5740
5741 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT.  */
5742
5743 static rtx
5744 round_trampoline_addr (rtx tramp)
5745 {
5746   rtx temp, addend, mask;
5747
5748   /* If we don't need too much alignment, we'll have been guaranteed
5749      proper alignment by get_trampoline_type.  */
5750   if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5751     return tramp;
5752
5753   /* Round address up to desired boundary.  */
5754   temp = gen_reg_rtx (Pmode);
5755   addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5756   mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5757
5758   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5759                                temp, 0, OPTAB_LIB_WIDEN);
5760   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5761                                temp, 0, OPTAB_LIB_WIDEN);
5762
5763   return tramp;
5764 }
5765
5766 static rtx
5767 expand_builtin_init_trampoline (tree exp)
5768 {
5769   tree t_tramp, t_func, t_chain;
5770   rtx r_tramp, r_func, r_chain;
5771 #ifdef TRAMPOLINE_TEMPLATE
5772   rtx blktramp;
5773 #endif
5774
5775   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5776                          POINTER_TYPE, VOID_TYPE))
5777     return NULL_RTX;
5778
5779   t_tramp = CALL_EXPR_ARG (exp, 0);
5780   t_func = CALL_EXPR_ARG (exp, 1);
5781   t_chain = CALL_EXPR_ARG (exp, 2);
5782
5783   r_tramp = expand_normal (t_tramp);
5784   r_func = expand_normal (t_func);
5785   r_chain = expand_normal (t_chain);
5786
5787   /* Generate insns to initialize the trampoline.  */
5788   r_tramp = round_trampoline_addr (r_tramp);
5789 #ifdef TRAMPOLINE_TEMPLATE
5790   blktramp = gen_rtx_MEM (BLKmode, r_tramp);
5791   set_mem_align (blktramp, TRAMPOLINE_ALIGNMENT);
5792   emit_block_move (blktramp, assemble_trampoline_template (),
5793                    GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
5794 #endif
5795   trampolines_created = 1;
5796   INITIALIZE_TRAMPOLINE (r_tramp, r_func, r_chain);
5797
5798   return const0_rtx;
5799 }
5800
5801 static rtx
5802 expand_builtin_adjust_trampoline (tree exp)
5803 {
5804   rtx tramp;
5805
5806   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5807     return NULL_RTX;
5808
5809   tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5810   tramp = round_trampoline_addr (tramp);
5811 #ifdef TRAMPOLINE_ADJUST_ADDRESS
5812   TRAMPOLINE_ADJUST_ADDRESS (tramp);
5813 #endif
5814
5815   return tramp;
5816 }
5817
5818 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5819    function.  The function first checks whether the back end provides
5820    an insn to implement signbit for the respective mode.  If not, it
5821    checks whether the floating point format of the value is such that
5822    the sign bit can be extracted.  If that is not the case, the
5823    function returns NULL_RTX to indicate that a normal call should be
5824    emitted rather than expanding the function in-line.  EXP is the
5825    expression that is a call to the builtin function; if convenient,
5826    the result should be placed in TARGET.  */
5827 static rtx
5828 expand_builtin_signbit (tree exp, rtx target)
5829 {
5830   const struct real_format *fmt;
5831   enum machine_mode fmode, imode, rmode;
5832   HOST_WIDE_INT hi, lo;
5833   tree arg;
5834   int word, bitpos;
5835   enum insn_code icode;
5836   rtx temp;
5837
5838   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5839     return NULL_RTX;
5840
5841   arg = CALL_EXPR_ARG (exp, 0);
5842   fmode = TYPE_MODE (TREE_TYPE (arg));
5843   rmode = TYPE_MODE (TREE_TYPE (exp));
5844   fmt = REAL_MODE_FORMAT (fmode);
5845
5846   arg = builtin_save_expr (arg);
5847
5848   /* Expand the argument yielding a RTX expression. */
5849   temp = expand_normal (arg);
5850
5851   /* Check if the back end provides an insn that handles signbit for the
5852      argument's mode. */
5853   icode = signbit_optab->handlers [(int) fmode].insn_code;
5854   if (icode != CODE_FOR_nothing)
5855     {
5856       target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5857       emit_unop_insn (icode, target, temp, UNKNOWN);
5858       return target;
5859     }
5860
5861   /* For floating point formats without a sign bit, implement signbit
5862      as "ARG < 0.0".  */
5863   bitpos = fmt->signbit_ro;
5864   if (bitpos < 0)
5865   {
5866     /* But we can't do this if the format supports signed zero.  */
5867     if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5868       return NULL_RTX;
5869
5870     arg = fold_build2 (LT_EXPR, TREE_TYPE (exp), arg,
5871                        build_real (TREE_TYPE (arg), dconst0));
5872     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5873   }
5874
5875   if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5876     {
5877       imode = int_mode_for_mode (fmode);
5878       if (imode == BLKmode)
5879         return NULL_RTX;
5880       temp = gen_lowpart (imode, temp);
5881     }
5882   else
5883     {
5884       imode = word_mode;
5885       /* Handle targets with different FP word orders.  */
5886       if (FLOAT_WORDS_BIG_ENDIAN)
5887         word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5888       else
5889         word = bitpos / BITS_PER_WORD;
5890       temp = operand_subword_force (temp, word, fmode);
5891       bitpos = bitpos % BITS_PER_WORD;
5892     }
5893
5894   /* Force the intermediate word_mode (or narrower) result into a
5895      register.  This avoids attempting to create paradoxical SUBREGs
5896      of floating point modes below.  */
5897   temp = force_reg (imode, temp);
5898
5899   /* If the bitpos is within the "result mode" lowpart, the operation
5900      can be implement with a single bitwise AND.  Otherwise, we need
5901      a right shift and an AND.  */
5902
5903   if (bitpos < GET_MODE_BITSIZE (rmode))
5904     {
5905       if (bitpos < HOST_BITS_PER_WIDE_INT)
5906         {
5907           hi = 0;
5908           lo = (HOST_WIDE_INT) 1 << bitpos;
5909         }
5910       else
5911         {
5912           hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
5913           lo = 0;
5914         }
5915
5916       if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5917         temp = gen_lowpart (rmode, temp);
5918       temp = expand_binop (rmode, and_optab, temp,
5919                            immed_double_const (lo, hi, rmode),
5920                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5921     }
5922   else
5923     {
5924       /* Perform a logical right shift to place the signbit in the least
5925          significant bit, then truncate the result to the desired mode
5926          and mask just this bit.  */
5927       temp = expand_shift (RSHIFT_EXPR, imode, temp,
5928                            build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5929       temp = gen_lowpart (rmode, temp);
5930       temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5931                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5932     }
5933
5934   return temp;
5935 }
5936
5937 /* Expand fork or exec calls.  TARGET is the desired target of the
5938    call.  EXP is the call. FN is the
5939    identificator of the actual function.  IGNORE is nonzero if the
5940    value is to be ignored.  */
5941
5942 static rtx
5943 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5944 {
5945   tree id, decl;
5946   tree call;
5947
5948   /* If we are not profiling, just call the function.  */
5949   if (!profile_arc_flag)
5950     return NULL_RTX;
5951
5952   /* Otherwise call the wrapper.  This should be equivalent for the rest of
5953      compiler, so the code does not diverge, and the wrapper may run the
5954      code necessary for keeping the profiling sane.  */
5955
5956   switch (DECL_FUNCTION_CODE (fn))
5957     {
5958     case BUILT_IN_FORK:
5959       id = get_identifier ("__gcov_fork");
5960       break;
5961
5962     case BUILT_IN_EXECL:
5963       id = get_identifier ("__gcov_execl");
5964       break;
5965
5966     case BUILT_IN_EXECV:
5967       id = get_identifier ("__gcov_execv");
5968       break;
5969
5970     case BUILT_IN_EXECLP:
5971       id = get_identifier ("__gcov_execlp");
5972       break;
5973
5974     case BUILT_IN_EXECLE:
5975       id = get_identifier ("__gcov_execle");
5976       break;
5977
5978     case BUILT_IN_EXECVP:
5979       id = get_identifier ("__gcov_execvp");
5980       break;
5981
5982     case BUILT_IN_EXECVE:
5983       id = get_identifier ("__gcov_execve");
5984       break;
5985
5986     default:
5987       gcc_unreachable ();
5988     }
5989
5990   decl = build_decl (DECL_SOURCE_LOCATION (fn),
5991                      FUNCTION_DECL, id, TREE_TYPE (fn));
5992   DECL_EXTERNAL (decl) = 1;
5993   TREE_PUBLIC (decl) = 1;
5994   DECL_ARTIFICIAL (decl) = 1;
5995   TREE_NOTHROW (decl) = 1;
5996   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5997   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5998   call = rewrite_call_expr (exp, 0, decl, 0);
5999   return expand_call (call, target, ignore);
6000  }
6001
6002
6003 \f
6004 /* Reconstitute a mode for a __sync intrinsic operation.  Since the type of
6005    the pointer in these functions is void*, the tree optimizers may remove
6006    casts.  The mode computed in expand_builtin isn't reliable either, due
6007    to __sync_bool_compare_and_swap.
6008
6009    FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
6010    group of builtins.  This gives us log2 of the mode size.  */
6011
6012 static inline enum machine_mode
6013 get_builtin_sync_mode (int fcode_diff)
6014 {
6015   /* The size is not negotiable, so ask not to get BLKmode in return
6016      if the target indicates that a smaller size would be better.  */
6017   return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
6018 }
6019
6020 /* Expand the memory expression LOC and return the appropriate memory operand
6021    for the builtin_sync operations.  */
6022
6023 static rtx
6024 get_builtin_sync_mem (tree loc, enum machine_mode mode)
6025 {
6026   rtx addr, mem;
6027
6028   addr = expand_expr (loc, NULL_RTX, Pmode, EXPAND_SUM);
6029
6030   /* Note that we explicitly do not want any alias information for this
6031      memory, so that we kill all other live memories.  Otherwise we don't
6032      satisfy the full barrier semantics of the intrinsic.  */
6033   mem = validize_mem (gen_rtx_MEM (mode, addr));
6034
6035   set_mem_align (mem, get_pointer_alignment (loc, BIGGEST_ALIGNMENT));
6036   set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
6037   MEM_VOLATILE_P (mem) = 1;
6038
6039   return mem;
6040 }
6041
6042 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
6043    EXP is the CALL_EXPR.  CODE is the rtx code
6044    that corresponds to the arithmetic or logical operation from the name;
6045    an exception here is that NOT actually means NAND.  TARGET is an optional
6046    place for us to store the results; AFTER is true if this is the
6047    fetch_and_xxx form.  IGNORE is true if we don't actually care about
6048    the result of the operation at all.  */
6049
6050 static rtx
6051 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
6052                                enum rtx_code code, bool after,
6053                                rtx target, bool ignore)
6054 {
6055   rtx val, mem;
6056   enum machine_mode old_mode;
6057   location_t loc = EXPR_LOCATION (exp);
6058
6059   if (code == NOT && warn_sync_nand)
6060     {
6061       tree fndecl = get_callee_fndecl (exp);
6062       enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6063
6064       static bool warned_f_a_n, warned_n_a_f;
6065
6066       switch (fcode)
6067         {
6068         case BUILT_IN_FETCH_AND_NAND_1:
6069         case BUILT_IN_FETCH_AND_NAND_2:
6070         case BUILT_IN_FETCH_AND_NAND_4:
6071         case BUILT_IN_FETCH_AND_NAND_8:
6072         case BUILT_IN_FETCH_AND_NAND_16:
6073
6074           if (warned_f_a_n)
6075             break;
6076
6077           fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
6078           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
6079           warned_f_a_n = true;
6080           break;
6081
6082         case BUILT_IN_NAND_AND_FETCH_1:
6083         case BUILT_IN_NAND_AND_FETCH_2:
6084         case BUILT_IN_NAND_AND_FETCH_4:
6085         case BUILT_IN_NAND_AND_FETCH_8:
6086         case BUILT_IN_NAND_AND_FETCH_16:
6087
6088           if (warned_n_a_f)
6089             break;
6090
6091           fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
6092           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
6093           warned_n_a_f = true;
6094           break;
6095
6096         default:
6097           gcc_unreachable ();
6098         }
6099     }
6100
6101   /* Expand the operands.  */
6102   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
6103
6104   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
6105   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
6106      of CONST_INTs, where we know the old_mode only from the call argument.  */
6107   old_mode = GET_MODE (val);
6108   if (old_mode == VOIDmode)
6109     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
6110   val = convert_modes (mode, old_mode, val, 1);
6111
6112   if (ignore)
6113     return expand_sync_operation (mem, val, code);
6114   else
6115     return expand_sync_fetch_operation (mem, val, code, after, target);
6116 }
6117
6118 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
6119    intrinsics. EXP is the CALL_EXPR.  IS_BOOL is
6120    true if this is the boolean form.  TARGET is a place for us to store the
6121    results; this is NOT optional if IS_BOOL is true.  */
6122
6123 static rtx
6124 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
6125                                  bool is_bool, rtx target)
6126 {
6127   rtx old_val, new_val, mem;
6128   enum machine_mode old_mode;
6129
6130   /* Expand the operands.  */
6131   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
6132
6133
6134   old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX,
6135                          mode, EXPAND_NORMAL);
6136   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
6137      of CONST_INTs, where we know the old_mode only from the call argument.  */
6138   old_mode = GET_MODE (old_val);
6139   if (old_mode == VOIDmode)
6140     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
6141   old_val = convert_modes (mode, old_mode, old_val, 1);
6142
6143   new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL_RTX,
6144                          mode, EXPAND_NORMAL);
6145   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
6146      of CONST_INTs, where we know the old_mode only from the call argument.  */
6147   old_mode = GET_MODE (new_val);
6148   if (old_mode == VOIDmode)
6149     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2)));
6150   new_val = convert_modes (mode, old_mode, new_val, 1);
6151
6152   if (is_bool)
6153     return expand_bool_compare_and_swap (mem, old_val, new_val, target);
6154   else
6155     return expand_val_compare_and_swap (mem, old_val, new_val, target);
6156 }
6157
6158 /* Expand the __sync_lock_test_and_set intrinsic.  Note that the most
6159    general form is actually an atomic exchange, and some targets only
6160    support a reduced form with the second argument being a constant 1.
6161    EXP is the CALL_EXPR; TARGET is an optional place for us to store
6162    the results.  */
6163
6164 static rtx
6165 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
6166                                   rtx target)
6167 {
6168   rtx val, mem;
6169   enum machine_mode old_mode;
6170
6171   /* Expand the operands.  */
6172   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
6173   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
6174   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
6175      of CONST_INTs, where we know the old_mode only from the call argument.  */
6176   old_mode = GET_MODE (val);
6177   if (old_mode == VOIDmode)
6178     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
6179   val = convert_modes (mode, old_mode, val, 1);
6180
6181   return expand_sync_lock_test_and_set (mem, val, target);
6182 }
6183
6184 /* Expand the __sync_synchronize intrinsic.  */
6185
6186 static void
6187 expand_builtin_synchronize (void)
6188 {
6189   tree x;
6190
6191 #ifdef HAVE_memory_barrier
6192   if (HAVE_memory_barrier)
6193     {
6194       emit_insn (gen_memory_barrier ());
6195       return;
6196     }
6197 #endif
6198
6199   if (synchronize_libfunc != NULL_RTX)
6200     {
6201       emit_library_call (synchronize_libfunc, LCT_NORMAL, VOIDmode, 0);
6202       return;
6203     }
6204
6205   /* If no explicit memory barrier instruction is available, create an
6206      empty asm stmt with a memory clobber.  */
6207   x = build4 (ASM_EXPR, void_type_node, build_string (0, ""), NULL, NULL,
6208               tree_cons (NULL, build_string (6, "memory"), NULL));
6209   ASM_VOLATILE_P (x) = 1;
6210   expand_asm_expr (x);
6211 }
6212
6213 /* Expand the __sync_lock_release intrinsic.  EXP is the CALL_EXPR.  */
6214
6215 static void
6216 expand_builtin_lock_release (enum machine_mode mode, tree exp)
6217 {
6218   enum insn_code icode;
6219   rtx mem, insn;
6220   rtx val = const0_rtx;
6221
6222   /* Expand the operands.  */
6223   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
6224
6225   /* If there is an explicit operation in the md file, use it.  */
6226   icode = sync_lock_release[mode];
6227   if (icode != CODE_FOR_nothing)
6228     {
6229       if (!insn_data[icode].operand[1].predicate (val, mode))
6230         val = force_reg (mode, val);
6231
6232       insn = GEN_FCN (icode) (mem, val);
6233       if (insn)
6234         {
6235           emit_insn (insn);
6236           return;
6237         }
6238     }
6239
6240   /* Otherwise we can implement this operation by emitting a barrier
6241      followed by a store of zero.  */
6242   expand_builtin_synchronize ();
6243   emit_move_insn (mem, val);
6244 }
6245 \f
6246 /* Expand an expression EXP that calls a built-in function,
6247    with result going to TARGET if that's convenient
6248    (and in mode MODE if that's convenient).
6249    SUBTARGET may be used as the target for computing one of EXP's operands.
6250    IGNORE is nonzero if the value is to be ignored.  */
6251
6252 rtx
6253 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
6254                 int ignore)
6255 {
6256   tree fndecl = get_callee_fndecl (exp);
6257   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6258   enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
6259
6260   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6261     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
6262
6263   /* When not optimizing, generate calls to library functions for a certain
6264      set of builtins.  */
6265   if (!optimize
6266       && !called_as_built_in (fndecl)
6267       && DECL_ASSEMBLER_NAME_SET_P (fndecl)
6268       && fcode != BUILT_IN_ALLOCA
6269       && fcode != BUILT_IN_FREE)
6270     return expand_call (exp, target, ignore);
6271
6272   /* The built-in function expanders test for target == const0_rtx
6273      to determine whether the function's result will be ignored.  */
6274   if (ignore)
6275     target = const0_rtx;
6276
6277   /* If the result of a pure or const built-in function is ignored, and
6278      none of its arguments are volatile, we can avoid expanding the
6279      built-in call and just evaluate the arguments for side-effects.  */
6280   if (target == const0_rtx
6281       && (DECL_PURE_P (fndecl) || TREE_READONLY (fndecl)))
6282     {
6283       bool volatilep = false;
6284       tree arg;
6285       call_expr_arg_iterator iter;
6286
6287       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
6288         if (TREE_THIS_VOLATILE (arg))
6289           {
6290             volatilep = true;
6291             break;
6292           }
6293
6294       if (! volatilep)
6295         {
6296           FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
6297             expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
6298           return const0_rtx;
6299         }
6300     }
6301
6302   switch (fcode)
6303     {
6304     CASE_FLT_FN (BUILT_IN_FABS):
6305       target = expand_builtin_fabs (exp, target, subtarget);
6306       if (target)
6307         return target;
6308       break;
6309
6310     CASE_FLT_FN (BUILT_IN_COPYSIGN):
6311       target = expand_builtin_copysign (exp, target, subtarget);
6312       if (target)
6313         return target;
6314       break;
6315
6316       /* Just do a normal library call if we were unable to fold
6317          the values.  */
6318     CASE_FLT_FN (BUILT_IN_CABS):
6319       break;
6320
6321     CASE_FLT_FN (BUILT_IN_EXP):
6322     CASE_FLT_FN (BUILT_IN_EXP10):
6323     CASE_FLT_FN (BUILT_IN_POW10):
6324     CASE_FLT_FN (BUILT_IN_EXP2):
6325     CASE_FLT_FN (BUILT_IN_EXPM1):
6326     CASE_FLT_FN (BUILT_IN_LOGB):
6327     CASE_FLT_FN (BUILT_IN_LOG):
6328     CASE_FLT_FN (BUILT_IN_LOG10):
6329     CASE_FLT_FN (BUILT_IN_LOG2):
6330     CASE_FLT_FN (BUILT_IN_LOG1P):
6331     CASE_FLT_FN (BUILT_IN_TAN):
6332     CASE_FLT_FN (BUILT_IN_ASIN):
6333     CASE_FLT_FN (BUILT_IN_ACOS):
6334     CASE_FLT_FN (BUILT_IN_ATAN):
6335       /* Treat these like sqrt only if unsafe math optimizations are allowed,
6336          because of possible accuracy problems.  */
6337       if (! flag_unsafe_math_optimizations)
6338         break;
6339     CASE_FLT_FN (BUILT_IN_SQRT):
6340     CASE_FLT_FN (BUILT_IN_FLOOR):
6341     CASE_FLT_FN (BUILT_IN_CEIL):
6342     CASE_FLT_FN (BUILT_IN_TRUNC):
6343     CASE_FLT_FN (BUILT_IN_ROUND):
6344     CASE_FLT_FN (BUILT_IN_NEARBYINT):
6345     CASE_FLT_FN (BUILT_IN_RINT):
6346       target = expand_builtin_mathfn (exp, target, subtarget);
6347       if (target)
6348         return target;
6349       break;
6350
6351     CASE_FLT_FN (BUILT_IN_ILOGB):
6352       if (! flag_unsafe_math_optimizations)
6353         break;
6354     CASE_FLT_FN (BUILT_IN_ISINF):
6355     CASE_FLT_FN (BUILT_IN_FINITE):
6356     case BUILT_IN_ISFINITE:
6357     case BUILT_IN_ISNORMAL:
6358       target = expand_builtin_interclass_mathfn (exp, target, subtarget);
6359       if (target)
6360         return target;
6361       break;
6362
6363     CASE_FLT_FN (BUILT_IN_LCEIL):
6364     CASE_FLT_FN (BUILT_IN_LLCEIL):
6365     CASE_FLT_FN (BUILT_IN_LFLOOR):
6366     CASE_FLT_FN (BUILT_IN_LLFLOOR):
6367       target = expand_builtin_int_roundingfn (exp, target);
6368       if (target)
6369         return target;
6370       break;
6371
6372     CASE_FLT_FN (BUILT_IN_LRINT):
6373     CASE_FLT_FN (BUILT_IN_LLRINT):
6374     CASE_FLT_FN (BUILT_IN_LROUND):
6375     CASE_FLT_FN (BUILT_IN_LLROUND):
6376       target = expand_builtin_int_roundingfn_2 (exp, target);
6377       if (target)
6378         return target;
6379       break;
6380
6381     CASE_FLT_FN (BUILT_IN_POW):
6382       target = expand_builtin_pow (exp, target, subtarget);
6383       if (target)
6384         return target;
6385       break;
6386
6387     CASE_FLT_FN (BUILT_IN_POWI):
6388       target = expand_builtin_powi (exp, target, subtarget);
6389       if (target)
6390         return target;
6391       break;
6392
6393     CASE_FLT_FN (BUILT_IN_ATAN2):
6394     CASE_FLT_FN (BUILT_IN_LDEXP):
6395     CASE_FLT_FN (BUILT_IN_SCALB):
6396     CASE_FLT_FN (BUILT_IN_SCALBN):
6397     CASE_FLT_FN (BUILT_IN_SCALBLN):
6398       if (! flag_unsafe_math_optimizations)
6399         break;
6400
6401     CASE_FLT_FN (BUILT_IN_FMOD):
6402     CASE_FLT_FN (BUILT_IN_REMAINDER):
6403     CASE_FLT_FN (BUILT_IN_DREM):
6404       target = expand_builtin_mathfn_2 (exp, target, subtarget);
6405       if (target)
6406         return target;
6407       break;
6408
6409     CASE_FLT_FN (BUILT_IN_CEXPI):
6410       target = expand_builtin_cexpi (exp, target, subtarget);
6411       gcc_assert (target);
6412       return target;
6413
6414     CASE_FLT_FN (BUILT_IN_SIN):
6415     CASE_FLT_FN (BUILT_IN_COS):
6416       if (! flag_unsafe_math_optimizations)
6417         break;
6418       target = expand_builtin_mathfn_3 (exp, target, subtarget);
6419       if (target)
6420         return target;
6421       break;
6422
6423     CASE_FLT_FN (BUILT_IN_SINCOS):
6424       if (! flag_unsafe_math_optimizations)
6425         break;
6426       target = expand_builtin_sincos (exp);
6427       if (target)
6428         return target;
6429       break;
6430
6431     case BUILT_IN_APPLY_ARGS:
6432       return expand_builtin_apply_args ();
6433
6434       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
6435          FUNCTION with a copy of the parameters described by
6436          ARGUMENTS, and ARGSIZE.  It returns a block of memory
6437          allocated on the stack into which is stored all the registers
6438          that might possibly be used for returning the result of a
6439          function.  ARGUMENTS is the value returned by
6440          __builtin_apply_args.  ARGSIZE is the number of bytes of
6441          arguments that must be copied.  ??? How should this value be
6442          computed?  We'll also need a safe worst case value for varargs
6443          functions.  */
6444     case BUILT_IN_APPLY:
6445       if (!validate_arglist (exp, POINTER_TYPE,
6446                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
6447           && !validate_arglist (exp, REFERENCE_TYPE,
6448                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6449         return const0_rtx;
6450       else
6451         {
6452           rtx ops[3];
6453
6454           ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
6455           ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
6456           ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
6457
6458           return expand_builtin_apply (ops[0], ops[1], ops[2]);
6459         }
6460
6461       /* __builtin_return (RESULT) causes the function to return the
6462          value described by RESULT.  RESULT is address of the block of
6463          memory returned by __builtin_apply.  */
6464     case BUILT_IN_RETURN:
6465       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6466         expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
6467       return const0_rtx;
6468
6469     case BUILT_IN_SAVEREGS:
6470       return expand_builtin_saveregs ();
6471
6472     case BUILT_IN_ARGS_INFO:
6473       return expand_builtin_args_info (exp);
6474
6475     case BUILT_IN_VA_ARG_PACK:
6476       /* All valid uses of __builtin_va_arg_pack () are removed during
6477          inlining.  */
6478       error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
6479       return const0_rtx;
6480
6481     case BUILT_IN_VA_ARG_PACK_LEN:
6482       /* All valid uses of __builtin_va_arg_pack_len () are removed during
6483          inlining.  */
6484       error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
6485       return const0_rtx;
6486
6487       /* Return the address of the first anonymous stack arg.  */
6488     case BUILT_IN_NEXT_ARG:
6489       if (fold_builtin_next_arg (exp, false))
6490         return const0_rtx;
6491       return expand_builtin_next_arg ();
6492
6493     case BUILT_IN_CLEAR_CACHE:
6494       target = expand_builtin___clear_cache (exp);
6495       if (target)
6496         return target;
6497       break;
6498
6499     case BUILT_IN_CLASSIFY_TYPE:
6500       return expand_builtin_classify_type (exp);
6501
6502     case BUILT_IN_CONSTANT_P:
6503       return const0_rtx;
6504
6505     case BUILT_IN_FRAME_ADDRESS:
6506     case BUILT_IN_RETURN_ADDRESS:
6507       return expand_builtin_frame_address (fndecl, exp);
6508
6509     /* Returns the address of the area where the structure is returned.
6510        0 otherwise.  */
6511     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
6512       if (call_expr_nargs (exp) != 0
6513           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
6514           || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
6515         return const0_rtx;
6516       else
6517         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6518
6519     case BUILT_IN_ALLOCA:
6520       target = expand_builtin_alloca (exp, target);
6521       if (target)
6522         return target;
6523       break;
6524
6525     case BUILT_IN_STACK_SAVE:
6526       return expand_stack_save ();
6527
6528     case BUILT_IN_STACK_RESTORE:
6529       expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6530       return const0_rtx;
6531
6532     case BUILT_IN_BSWAP32:
6533     case BUILT_IN_BSWAP64:
6534       target = expand_builtin_bswap (exp, target, subtarget);
6535
6536       if (target)
6537         return target;
6538       break;
6539
6540     CASE_INT_FN (BUILT_IN_FFS):
6541     case BUILT_IN_FFSIMAX:
6542       target = expand_builtin_unop (target_mode, exp, target,
6543                                     subtarget, ffs_optab);
6544       if (target)
6545         return target;
6546       break;
6547
6548     CASE_INT_FN (BUILT_IN_CLZ):
6549     case BUILT_IN_CLZIMAX:
6550       target = expand_builtin_unop (target_mode, exp, target,
6551                                     subtarget, clz_optab);
6552       if (target)
6553         return target;
6554       break;
6555
6556     CASE_INT_FN (BUILT_IN_CTZ):
6557     case BUILT_IN_CTZIMAX:
6558       target = expand_builtin_unop (target_mode, exp, target,
6559                                     subtarget, ctz_optab);
6560       if (target)
6561         return target;
6562       break;
6563
6564     CASE_INT_FN (BUILT_IN_POPCOUNT):
6565     case BUILT_IN_POPCOUNTIMAX:
6566       target = expand_builtin_unop (target_mode, exp, target,
6567                                     subtarget, popcount_optab);
6568       if (target)
6569         return target;
6570       break;
6571
6572     CASE_INT_FN (BUILT_IN_PARITY):
6573     case BUILT_IN_PARITYIMAX:
6574       target = expand_builtin_unop (target_mode, exp, target,
6575                                     subtarget, parity_optab);
6576       if (target)
6577         return target;
6578       break;
6579
6580     case BUILT_IN_STRLEN:
6581       target = expand_builtin_strlen (exp, target, target_mode);
6582       if (target)
6583         return target;
6584       break;
6585
6586     case BUILT_IN_STRCPY:
6587       target = expand_builtin_strcpy (fndecl, exp, target, mode);
6588       if (target)
6589         return target;
6590       break;
6591
6592     case BUILT_IN_STRNCPY:
6593       target = expand_builtin_strncpy (exp, target, mode);
6594       if (target)
6595         return target;
6596       break;
6597
6598     case BUILT_IN_STPCPY:
6599       target = expand_builtin_stpcpy (exp, target, mode);
6600       if (target)
6601         return target;
6602       break;
6603
6604     case BUILT_IN_STRCAT:
6605       target = expand_builtin_strcat (fndecl, exp, target, mode);
6606       if (target)
6607         return target;
6608       break;
6609
6610     case BUILT_IN_STRNCAT:
6611       target = expand_builtin_strncat (exp, target, mode);
6612       if (target)
6613         return target;
6614       break;
6615
6616     case BUILT_IN_STRSPN:
6617       target = expand_builtin_strspn (exp, target, mode);
6618       if (target)
6619         return target;
6620       break;
6621
6622     case BUILT_IN_STRCSPN:
6623       target = expand_builtin_strcspn (exp, target, mode);
6624       if (target)
6625         return target;
6626       break;
6627
6628     case BUILT_IN_STRSTR:
6629       target = expand_builtin_strstr (exp, target, mode);
6630       if (target)
6631         return target;
6632       break;
6633
6634     case BUILT_IN_STRPBRK:
6635       target = expand_builtin_strpbrk (exp, target, mode);
6636       if (target)
6637         return target;
6638       break;
6639
6640     case BUILT_IN_INDEX:
6641     case BUILT_IN_STRCHR:
6642       target = expand_builtin_strchr (exp, target, mode);
6643       if (target)
6644         return target;
6645       break;
6646
6647     case BUILT_IN_RINDEX:
6648     case BUILT_IN_STRRCHR:
6649       target = expand_builtin_strrchr (exp, target, mode);
6650       if (target)
6651         return target;
6652       break;
6653
6654     case BUILT_IN_MEMCPY:
6655       target = expand_builtin_memcpy (exp, target, mode);
6656       if (target)
6657         return target;
6658       break;
6659
6660     case BUILT_IN_MEMPCPY:
6661       target = expand_builtin_mempcpy (exp, target, mode);
6662       if (target)
6663         return target;
6664       break;
6665
6666     case BUILT_IN_MEMMOVE:
6667       target = expand_builtin_memmove (exp, target, mode, ignore);
6668       if (target)
6669         return target;
6670       break;
6671
6672     case BUILT_IN_BCOPY:
6673       target = expand_builtin_bcopy (exp, ignore);
6674       if (target)
6675         return target;
6676       break;
6677
6678     case BUILT_IN_MEMSET:
6679       target = expand_builtin_memset (exp, target, mode);
6680       if (target)
6681         return target;
6682       break;
6683
6684     case BUILT_IN_BZERO:
6685       target = expand_builtin_bzero (exp);
6686       if (target)
6687         return target;
6688       break;
6689
6690     case BUILT_IN_STRCMP:
6691       target = expand_builtin_strcmp (exp, target, mode);
6692       if (target)
6693         return target;
6694       break;
6695
6696     case BUILT_IN_STRNCMP:
6697       target = expand_builtin_strncmp (exp, target, mode);
6698       if (target)
6699         return target;
6700       break;
6701
6702     case BUILT_IN_MEMCHR:
6703       target = expand_builtin_memchr (exp, target, mode);
6704       if (target)
6705         return target;
6706       break;
6707
6708     case BUILT_IN_BCMP:
6709     case BUILT_IN_MEMCMP:
6710       target = expand_builtin_memcmp (exp, target, mode);
6711       if (target)
6712         return target;
6713       break;
6714
6715     case BUILT_IN_SETJMP:
6716       /* This should have been lowered to the builtins below.  */
6717       gcc_unreachable ();
6718
6719     case BUILT_IN_SETJMP_SETUP:
6720       /* __builtin_setjmp_setup is passed a pointer to an array of five words
6721           and the receiver label.  */
6722       if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6723         {
6724           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6725                                       VOIDmode, EXPAND_NORMAL);
6726           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6727           rtx label_r = label_rtx (label);
6728
6729           /* This is copied from the handling of non-local gotos.  */
6730           expand_builtin_setjmp_setup (buf_addr, label_r);
6731           nonlocal_goto_handler_labels
6732             = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6733                                  nonlocal_goto_handler_labels);
6734           /* ??? Do not let expand_label treat us as such since we would
6735              not want to be both on the list of non-local labels and on
6736              the list of forced labels.  */
6737           FORCED_LABEL (label) = 0;
6738           return const0_rtx;
6739         }
6740       break;
6741
6742     case BUILT_IN_SETJMP_DISPATCHER:
6743        /* __builtin_setjmp_dispatcher is passed the dispatcher label.  */
6744       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6745         {
6746           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6747           rtx label_r = label_rtx (label);
6748
6749           /* Remove the dispatcher label from the list of non-local labels
6750              since the receiver labels have been added to it above.  */
6751           remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6752           return const0_rtx;
6753         }
6754       break;
6755
6756     case BUILT_IN_SETJMP_RECEIVER:
6757        /* __builtin_setjmp_receiver is passed the receiver label.  */
6758       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6759         {
6760           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6761           rtx label_r = label_rtx (label);
6762
6763           expand_builtin_setjmp_receiver (label_r);
6764           return const0_rtx;
6765         }
6766       break;
6767
6768       /* __builtin_longjmp is passed a pointer to an array of five words.
6769          It's similar to the C library longjmp function but works with
6770          __builtin_setjmp above.  */
6771     case BUILT_IN_LONGJMP:
6772       if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6773         {
6774           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6775                                       VOIDmode, EXPAND_NORMAL);
6776           rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6777
6778           if (value != const1_rtx)
6779             {
6780               error ("%<__builtin_longjmp%> second argument must be 1");
6781               return const0_rtx;
6782             }
6783
6784           expand_builtin_longjmp (buf_addr, value);
6785           return const0_rtx;
6786         }
6787       break;
6788
6789     case BUILT_IN_NONLOCAL_GOTO:
6790       target = expand_builtin_nonlocal_goto (exp);
6791       if (target)
6792         return target;
6793       break;
6794
6795       /* This updates the setjmp buffer that is its argument with the value
6796          of the current stack pointer.  */
6797     case BUILT_IN_UPDATE_SETJMP_BUF:
6798       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6799         {
6800           rtx buf_addr
6801             = expand_normal (CALL_EXPR_ARG (exp, 0));
6802
6803           expand_builtin_update_setjmp_buf (buf_addr);
6804           return const0_rtx;
6805         }
6806       break;
6807
6808     case BUILT_IN_TRAP:
6809       expand_builtin_trap ();
6810       return const0_rtx;
6811
6812     case BUILT_IN_UNREACHABLE:
6813       expand_builtin_unreachable ();
6814       return const0_rtx;
6815
6816     case BUILT_IN_PRINTF:
6817       target = expand_builtin_printf (exp, target, mode, false);
6818       if (target)
6819         return target;
6820       break;
6821
6822     case BUILT_IN_PRINTF_UNLOCKED:
6823       target = expand_builtin_printf (exp, target, mode, true);
6824       if (target)
6825         return target;
6826       break;
6827
6828     case BUILT_IN_FPUTS:
6829       target = expand_builtin_fputs (exp, target, false);
6830       if (target)
6831         return target;
6832       break;
6833     case BUILT_IN_FPUTS_UNLOCKED:
6834       target = expand_builtin_fputs (exp, target, true);
6835       if (target)
6836         return target;
6837       break;
6838
6839     case BUILT_IN_FPRINTF:
6840       target = expand_builtin_fprintf (exp, target, mode, false);
6841       if (target)
6842         return target;
6843       break;
6844
6845     case BUILT_IN_FPRINTF_UNLOCKED:
6846       target = expand_builtin_fprintf (exp, target, mode, true);
6847       if (target)
6848         return target;
6849       break;
6850
6851     case BUILT_IN_SPRINTF:
6852       target = expand_builtin_sprintf (exp, target, mode);
6853       if (target)
6854         return target;
6855       break;
6856
6857     CASE_FLT_FN (BUILT_IN_SIGNBIT):
6858     case BUILT_IN_SIGNBITD32:
6859     case BUILT_IN_SIGNBITD64:
6860     case BUILT_IN_SIGNBITD128:
6861       target = expand_builtin_signbit (exp, target);
6862       if (target)
6863         return target;
6864       break;
6865
6866       /* Various hooks for the DWARF 2 __throw routine.  */
6867     case BUILT_IN_UNWIND_INIT:
6868       expand_builtin_unwind_init ();
6869       return const0_rtx;
6870     case BUILT_IN_DWARF_CFA:
6871       return virtual_cfa_rtx;
6872 #ifdef DWARF2_UNWIND_INFO
6873     case BUILT_IN_DWARF_SP_COLUMN:
6874       return expand_builtin_dwarf_sp_column ();
6875     case BUILT_IN_INIT_DWARF_REG_SIZES:
6876       expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6877       return const0_rtx;
6878 #endif
6879     case BUILT_IN_FROB_RETURN_ADDR:
6880       return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6881     case BUILT_IN_EXTRACT_RETURN_ADDR:
6882       return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6883     case BUILT_IN_EH_RETURN:
6884       expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6885                                 CALL_EXPR_ARG (exp, 1));
6886       return const0_rtx;
6887 #ifdef EH_RETURN_DATA_REGNO
6888     case BUILT_IN_EH_RETURN_DATA_REGNO:
6889       return expand_builtin_eh_return_data_regno (exp);
6890 #endif
6891     case BUILT_IN_EXTEND_POINTER:
6892       return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6893
6894     case BUILT_IN_VA_START:
6895       return expand_builtin_va_start (exp);
6896     case BUILT_IN_VA_END:
6897       return expand_builtin_va_end (exp);
6898     case BUILT_IN_VA_COPY:
6899       return expand_builtin_va_copy (exp);
6900     case BUILT_IN_EXPECT:
6901       return expand_builtin_expect (exp, target);
6902     case BUILT_IN_PREFETCH:
6903       expand_builtin_prefetch (exp);
6904       return const0_rtx;
6905
6906     case BUILT_IN_PROFILE_FUNC_ENTER:
6907       return expand_builtin_profile_func (false);
6908     case BUILT_IN_PROFILE_FUNC_EXIT:
6909       return expand_builtin_profile_func (true);
6910
6911     case BUILT_IN_INIT_TRAMPOLINE:
6912       return expand_builtin_init_trampoline (exp);
6913     case BUILT_IN_ADJUST_TRAMPOLINE:
6914       return expand_builtin_adjust_trampoline (exp);
6915
6916     case BUILT_IN_FORK:
6917     case BUILT_IN_EXECL:
6918     case BUILT_IN_EXECV:
6919     case BUILT_IN_EXECLP:
6920     case BUILT_IN_EXECLE:
6921     case BUILT_IN_EXECVP:
6922     case BUILT_IN_EXECVE:
6923       target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6924       if (target)
6925         return target;
6926       break;
6927
6928     case BUILT_IN_FETCH_AND_ADD_1:
6929     case BUILT_IN_FETCH_AND_ADD_2:
6930     case BUILT_IN_FETCH_AND_ADD_4:
6931     case BUILT_IN_FETCH_AND_ADD_8:
6932     case BUILT_IN_FETCH_AND_ADD_16:
6933       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6934       target = expand_builtin_sync_operation (mode, exp, PLUS,
6935                                               false, target, ignore);
6936       if (target)
6937         return target;
6938       break;
6939
6940     case BUILT_IN_FETCH_AND_SUB_1:
6941     case BUILT_IN_FETCH_AND_SUB_2:
6942     case BUILT_IN_FETCH_AND_SUB_4:
6943     case BUILT_IN_FETCH_AND_SUB_8:
6944     case BUILT_IN_FETCH_AND_SUB_16:
6945       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6946       target = expand_builtin_sync_operation (mode, exp, MINUS,
6947                                               false, target, ignore);
6948       if (target)
6949         return target;
6950       break;
6951
6952     case BUILT_IN_FETCH_AND_OR_1:
6953     case BUILT_IN_FETCH_AND_OR_2:
6954     case BUILT_IN_FETCH_AND_OR_4:
6955     case BUILT_IN_FETCH_AND_OR_8:
6956     case BUILT_IN_FETCH_AND_OR_16:
6957       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6958       target = expand_builtin_sync_operation (mode, exp, IOR,
6959                                               false, target, ignore);
6960       if (target)
6961         return target;
6962       break;
6963
6964     case BUILT_IN_FETCH_AND_AND_1:
6965     case BUILT_IN_FETCH_AND_AND_2:
6966     case BUILT_IN_FETCH_AND_AND_4:
6967     case BUILT_IN_FETCH_AND_AND_8:
6968     case BUILT_IN_FETCH_AND_AND_16:
6969       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6970       target = expand_builtin_sync_operation (mode, exp, AND,
6971                                               false, target, ignore);
6972       if (target)
6973         return target;
6974       break;
6975
6976     case BUILT_IN_FETCH_AND_XOR_1:
6977     case BUILT_IN_FETCH_AND_XOR_2:
6978     case BUILT_IN_FETCH_AND_XOR_4:
6979     case BUILT_IN_FETCH_AND_XOR_8:
6980     case BUILT_IN_FETCH_AND_XOR_16:
6981       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6982       target = expand_builtin_sync_operation (mode, exp, XOR,
6983                                               false, target, ignore);
6984       if (target)
6985         return target;
6986       break;
6987
6988     case BUILT_IN_FETCH_AND_NAND_1:
6989     case BUILT_IN_FETCH_AND_NAND_2:
6990     case BUILT_IN_FETCH_AND_NAND_4:
6991     case BUILT_IN_FETCH_AND_NAND_8:
6992     case BUILT_IN_FETCH_AND_NAND_16:
6993       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6994       target = expand_builtin_sync_operation (mode, exp, NOT,
6995                                               false, target, ignore);
6996       if (target)
6997         return target;
6998       break;
6999
7000     case BUILT_IN_ADD_AND_FETCH_1:
7001     case BUILT_IN_ADD_AND_FETCH_2:
7002     case BUILT_IN_ADD_AND_FETCH_4:
7003     case BUILT_IN_ADD_AND_FETCH_8:
7004     case BUILT_IN_ADD_AND_FETCH_16:
7005       mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
7006       target = expand_builtin_sync_operation (mode, exp, PLUS,
7007                                               true, target, ignore);
7008       if (target)
7009         return target;
7010       break;
7011
7012     case BUILT_IN_SUB_AND_FETCH_1:
7013     case BUILT_IN_SUB_AND_FETCH_2:
7014     case BUILT_IN_SUB_AND_FETCH_4:
7015     case BUILT_IN_SUB_AND_FETCH_8:
7016     case BUILT_IN_SUB_AND_FETCH_16:
7017       mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
7018       target = expand_builtin_sync_operation (mode, exp, MINUS,
7019                                               true, target, ignore);
7020       if (target)
7021         return target;
7022       break;
7023
7024     case BUILT_IN_OR_AND_FETCH_1:
7025     case BUILT_IN_OR_AND_FETCH_2:
7026     case BUILT_IN_OR_AND_FETCH_4:
7027     case BUILT_IN_OR_AND_FETCH_8:
7028     case BUILT_IN_OR_AND_FETCH_16:
7029       mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
7030       target = expand_builtin_sync_operation (mode, exp, IOR,
7031                                               true, target, ignore);
7032       if (target)
7033         return target;
7034       break;
7035
7036     case BUILT_IN_AND_AND_FETCH_1:
7037     case BUILT_IN_AND_AND_FETCH_2:
7038     case BUILT_IN_AND_AND_FETCH_4:
7039     case BUILT_IN_AND_AND_FETCH_8:
7040     case BUILT_IN_AND_AND_FETCH_16:
7041       mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
7042       target = expand_builtin_sync_operation (mode, exp, AND,
7043                                               true, target, ignore);
7044       if (target)
7045         return target;
7046       break;
7047
7048     case BUILT_IN_XOR_AND_FETCH_1:
7049     case BUILT_IN_XOR_AND_FETCH_2:
7050     case BUILT_IN_XOR_AND_FETCH_4:
7051     case BUILT_IN_XOR_AND_FETCH_8:
7052     case BUILT_IN_XOR_AND_FETCH_16:
7053       mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
7054       target = expand_builtin_sync_operation (mode, exp, XOR,
7055                                               true, target, ignore);
7056       if (target)
7057         return target;
7058       break;
7059
7060     case BUILT_IN_NAND_AND_FETCH_1:
7061     case BUILT_IN_NAND_AND_FETCH_2:
7062     case BUILT_IN_NAND_AND_FETCH_4:
7063     case BUILT_IN_NAND_AND_FETCH_8:
7064     case BUILT_IN_NAND_AND_FETCH_16:
7065       mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
7066       target = expand_builtin_sync_operation (mode, exp, NOT,
7067                                               true, target, ignore);
7068       if (target)
7069         return target;
7070       break;
7071
7072     case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
7073     case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
7074     case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
7075     case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
7076     case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
7077       if (mode == VOIDmode)
7078         mode = TYPE_MODE (boolean_type_node);
7079       if (!target || !register_operand (target, mode))
7080         target = gen_reg_rtx (mode);
7081
7082       mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
7083       target = expand_builtin_compare_and_swap (mode, exp, true, target);
7084       if (target)
7085         return target;
7086       break;
7087
7088     case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
7089     case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
7090     case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
7091     case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
7092     case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
7093       mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
7094       target = expand_builtin_compare_and_swap (mode, exp, false, target);
7095       if (target)
7096         return target;
7097       break;
7098
7099     case BUILT_IN_LOCK_TEST_AND_SET_1:
7100     case BUILT_IN_LOCK_TEST_AND_SET_2:
7101     case BUILT_IN_LOCK_TEST_AND_SET_4:
7102     case BUILT_IN_LOCK_TEST_AND_SET_8:
7103     case BUILT_IN_LOCK_TEST_AND_SET_16:
7104       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
7105       target = expand_builtin_lock_test_and_set (mode, exp, target);
7106       if (target)
7107         return target;
7108       break;
7109
7110     case BUILT_IN_LOCK_RELEASE_1:
7111     case BUILT_IN_LOCK_RELEASE_2:
7112     case BUILT_IN_LOCK_RELEASE_4:
7113     case BUILT_IN_LOCK_RELEASE_8:
7114     case BUILT_IN_LOCK_RELEASE_16:
7115       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
7116       expand_builtin_lock_release (mode, exp);
7117       return const0_rtx;
7118
7119     case BUILT_IN_SYNCHRONIZE:
7120       expand_builtin_synchronize ();
7121       return const0_rtx;
7122
7123     case BUILT_IN_OBJECT_SIZE:
7124       return expand_builtin_object_size (exp);
7125
7126     case BUILT_IN_MEMCPY_CHK:
7127     case BUILT_IN_MEMPCPY_CHK:
7128     case BUILT_IN_MEMMOVE_CHK:
7129     case BUILT_IN_MEMSET_CHK:
7130       target = expand_builtin_memory_chk (exp, target, mode, fcode);
7131       if (target)
7132         return target;
7133       break;
7134
7135     case BUILT_IN_STRCPY_CHK:
7136     case BUILT_IN_STPCPY_CHK:
7137     case BUILT_IN_STRNCPY_CHK:
7138     case BUILT_IN_STRCAT_CHK:
7139     case BUILT_IN_STRNCAT_CHK:
7140     case BUILT_IN_SNPRINTF_CHK:
7141     case BUILT_IN_VSNPRINTF_CHK:
7142       maybe_emit_chk_warning (exp, fcode);
7143       break;
7144
7145     case BUILT_IN_SPRINTF_CHK:
7146     case BUILT_IN_VSPRINTF_CHK:
7147       maybe_emit_sprintf_chk_warning (exp, fcode);
7148       break;
7149
7150     case BUILT_IN_FREE:
7151       maybe_emit_free_warning (exp);
7152       break;
7153
7154     default:    /* just do library call, if unknown builtin */
7155       break;
7156     }
7157
7158   /* The switch statement above can drop through to cause the function
7159      to be called normally.  */
7160   return expand_call (exp, target, ignore);
7161 }
7162
7163 /* Determine whether a tree node represents a call to a built-in
7164    function.  If the tree T is a call to a built-in function with
7165    the right number of arguments of the appropriate types, return
7166    the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
7167    Otherwise the return value is END_BUILTINS.  */
7168
7169 enum built_in_function
7170 builtin_mathfn_code (const_tree t)
7171 {
7172   const_tree fndecl, arg, parmlist;
7173   const_tree argtype, parmtype;
7174   const_call_expr_arg_iterator iter;
7175
7176   if (TREE_CODE (t) != CALL_EXPR
7177       || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
7178     return END_BUILTINS;
7179
7180   fndecl = get_callee_fndecl (t);
7181   if (fndecl == NULL_TREE
7182       || TREE_CODE (fndecl) != FUNCTION_DECL
7183       || ! DECL_BUILT_IN (fndecl)
7184       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
7185     return END_BUILTINS;
7186
7187   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
7188   init_const_call_expr_arg_iterator (t, &iter);
7189   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
7190     {
7191       /* If a function doesn't take a variable number of arguments,
7192          the last element in the list will have type `void'.  */
7193       parmtype = TREE_VALUE (parmlist);
7194       if (VOID_TYPE_P (parmtype))
7195         {
7196           if (more_const_call_expr_args_p (&iter))
7197             return END_BUILTINS;
7198           return DECL_FUNCTION_CODE (fndecl);
7199         }
7200
7201       if (! more_const_call_expr_args_p (&iter))
7202         return END_BUILTINS;
7203
7204       arg = next_const_call_expr_arg (&iter);
7205       argtype = TREE_TYPE (arg);
7206
7207       if (SCALAR_FLOAT_TYPE_P (parmtype))
7208         {
7209           if (! SCALAR_FLOAT_TYPE_P (argtype))
7210             return END_BUILTINS;
7211         }
7212       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
7213         {
7214           if (! COMPLEX_FLOAT_TYPE_P (argtype))
7215             return END_BUILTINS;
7216         }
7217       else if (POINTER_TYPE_P (parmtype))
7218         {
7219           if (! POINTER_TYPE_P (argtype))
7220             return END_BUILTINS;
7221         }
7222       else if (INTEGRAL_TYPE_P (parmtype))
7223         {
7224           if (! INTEGRAL_TYPE_P (argtype))
7225             return END_BUILTINS;
7226         }
7227       else
7228         return END_BUILTINS;
7229     }
7230
7231   /* Variable-length argument list.  */
7232   return DECL_FUNCTION_CODE (fndecl);
7233 }
7234
7235 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
7236    evaluate to a constant.  */
7237
7238 static tree
7239 fold_builtin_constant_p (tree arg)
7240 {
7241   /* We return 1 for a numeric type that's known to be a constant
7242      value at compile-time or for an aggregate type that's a
7243      literal constant.  */
7244   STRIP_NOPS (arg);
7245
7246   /* If we know this is a constant, emit the constant of one.  */
7247   if (CONSTANT_CLASS_P (arg)
7248       || (TREE_CODE (arg) == CONSTRUCTOR
7249           && TREE_CONSTANT (arg)))
7250     return integer_one_node;
7251   if (TREE_CODE (arg) == ADDR_EXPR)
7252     {
7253        tree op = TREE_OPERAND (arg, 0);
7254        if (TREE_CODE (op) == STRING_CST
7255            || (TREE_CODE (op) == ARRAY_REF
7256                && integer_zerop (TREE_OPERAND (op, 1))
7257                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
7258          return integer_one_node;
7259     }
7260
7261   /* If this expression has side effects, show we don't know it to be a
7262      constant.  Likewise if it's a pointer or aggregate type since in
7263      those case we only want literals, since those are only optimized
7264      when generating RTL, not later.
7265      And finally, if we are compiling an initializer, not code, we
7266      need to return a definite result now; there's not going to be any
7267      more optimization done.  */
7268   if (TREE_SIDE_EFFECTS (arg)
7269       || AGGREGATE_TYPE_P (TREE_TYPE (arg))
7270       || POINTER_TYPE_P (TREE_TYPE (arg))
7271       || cfun == 0
7272       || folding_initializer)
7273     return integer_zero_node;
7274
7275   return NULL_TREE;
7276 }
7277
7278 /* Create builtin_expect with PRED and EXPECTED as its arguments and
7279    return it as a truthvalue.  */
7280
7281 static tree
7282 build_builtin_expect_predicate (tree pred, tree expected)
7283 {
7284   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
7285
7286   fn = built_in_decls[BUILT_IN_EXPECT];
7287   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
7288   ret_type = TREE_TYPE (TREE_TYPE (fn));
7289   pred_type = TREE_VALUE (arg_types);
7290   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
7291
7292   pred = fold_convert (pred_type, pred);
7293   expected = fold_convert (expected_type, expected);
7294   call_expr = build_call_expr (fn, 2, pred, expected);
7295
7296   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
7297                  build_int_cst (ret_type, 0));
7298 }
7299
7300 /* Fold a call to builtin_expect with arguments ARG0 and ARG1.  Return
7301    NULL_TREE if no simplification is possible.  */
7302
7303 static tree
7304 fold_builtin_expect (tree arg0, tree arg1)
7305 {
7306   tree inner, fndecl;
7307   enum tree_code code;
7308
7309   /* If this is a builtin_expect within a builtin_expect keep the
7310      inner one.  See through a comparison against a constant.  It
7311      might have been added to create a thruthvalue.  */
7312   inner = arg0;
7313   if (COMPARISON_CLASS_P (inner)
7314       && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
7315     inner = TREE_OPERAND (inner, 0);
7316
7317   if (TREE_CODE (inner) == CALL_EXPR
7318       && (fndecl = get_callee_fndecl (inner))
7319       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
7320       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
7321     return arg0;
7322
7323   /* Distribute the expected value over short-circuiting operators.
7324      See through the cast from truthvalue_type_node to long.  */
7325   inner = arg0;
7326   while (TREE_CODE (inner) == NOP_EXPR
7327          && INTEGRAL_TYPE_P (TREE_TYPE (inner))
7328          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
7329     inner = TREE_OPERAND (inner, 0);
7330
7331   code = TREE_CODE (inner);
7332   if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
7333     {
7334       tree op0 = TREE_OPERAND (inner, 0);
7335       tree op1 = TREE_OPERAND (inner, 1);
7336
7337       op0 = build_builtin_expect_predicate (op0, arg1);
7338       op1 = build_builtin_expect_predicate (op1, arg1);
7339       inner = build2 (code, TREE_TYPE (inner), op0, op1);
7340
7341       return fold_convert (TREE_TYPE (arg0), inner);
7342     }
7343
7344   /* If the argument isn't invariant then there's nothing else we can do.  */
7345   if (!TREE_CONSTANT (arg0))
7346     return NULL_TREE;
7347
7348   /* If we expect that a comparison against the argument will fold to
7349      a constant return the constant.  In practice, this means a true
7350      constant or the address of a non-weak symbol.  */
7351   inner = arg0;
7352   STRIP_NOPS (inner);
7353   if (TREE_CODE (inner) == ADDR_EXPR)
7354     {
7355       do
7356         {
7357           inner = TREE_OPERAND (inner, 0);
7358         }
7359       while (TREE_CODE (inner) == COMPONENT_REF
7360              || TREE_CODE (inner) == ARRAY_REF);
7361       if ((TREE_CODE (inner) == VAR_DECL
7362            || TREE_CODE (inner) == FUNCTION_DECL)
7363           && DECL_WEAK (inner))
7364         return NULL_TREE;
7365     }
7366
7367   /* Otherwise, ARG0 already has the proper type for the return value.  */
7368   return arg0;
7369 }
7370
7371 /* Fold a call to __builtin_classify_type with argument ARG.  */
7372
7373 static tree
7374 fold_builtin_classify_type (tree arg)
7375 {
7376   if (arg == 0)
7377     return build_int_cst (NULL_TREE, no_type_class);
7378
7379   return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
7380 }
7381
7382 /* Fold a call to __builtin_strlen with argument ARG.  */
7383
7384 static tree
7385 fold_builtin_strlen (tree arg)
7386 {
7387   if (!validate_arg (arg, POINTER_TYPE))
7388     return NULL_TREE;
7389   else
7390     {
7391       tree len = c_strlen (arg, 0);
7392
7393       if (len)
7394         {
7395           /* Convert from the internal "sizetype" type to "size_t".  */
7396           if (size_type_node)
7397             len = fold_convert (size_type_node, len);
7398           return len;
7399         }
7400
7401       return NULL_TREE;
7402     }
7403 }
7404
7405 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
7406
7407 static tree
7408 fold_builtin_inf (tree type, int warn)
7409 {
7410   REAL_VALUE_TYPE real;
7411
7412   /* __builtin_inff is intended to be usable to define INFINITY on all
7413      targets.  If an infinity is not available, INFINITY expands "to a
7414      positive constant of type float that overflows at translation
7415      time", footnote "In this case, using INFINITY will violate the
7416      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
7417      Thus we pedwarn to ensure this constraint violation is
7418      diagnosed.  */
7419   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
7420     pedwarn (input_location, 0, "target format does not support infinity");
7421
7422   real_inf (&real);
7423   return build_real (type, real);
7424 }
7425
7426 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG.  */
7427
7428 static tree
7429 fold_builtin_nan (tree arg, tree type, int quiet)
7430 {
7431   REAL_VALUE_TYPE real;
7432   const char *str;
7433
7434   if (!validate_arg (arg, POINTER_TYPE))
7435     return NULL_TREE;
7436   str = c_getstr (arg);
7437   if (!str)
7438     return NULL_TREE;
7439
7440   if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
7441     return NULL_TREE;
7442
7443   return build_real (type, real);
7444 }
7445
7446 /* Return true if the floating point expression T has an integer value.
7447    We also allow +Inf, -Inf and NaN to be considered integer values.  */
7448
7449 static bool
7450 integer_valued_real_p (tree t)
7451 {
7452   switch (TREE_CODE (t))
7453     {
7454     case FLOAT_EXPR:
7455       return true;
7456
7457     case ABS_EXPR:
7458     case SAVE_EXPR:
7459       return integer_valued_real_p (TREE_OPERAND (t, 0));
7460
7461     case COMPOUND_EXPR:
7462     case MODIFY_EXPR:
7463     case BIND_EXPR:
7464       return integer_valued_real_p (TREE_OPERAND (t, 1));
7465
7466     case PLUS_EXPR:
7467     case MINUS_EXPR:
7468     case MULT_EXPR:
7469     case MIN_EXPR:
7470     case MAX_EXPR:
7471       return integer_valued_real_p (TREE_OPERAND (t, 0))
7472              && integer_valued_real_p (TREE_OPERAND (t, 1));
7473
7474     case COND_EXPR:
7475       return integer_valued_real_p (TREE_OPERAND (t, 1))
7476              && integer_valued_real_p (TREE_OPERAND (t, 2));
7477
7478     case REAL_CST:
7479       return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
7480
7481     case NOP_EXPR:
7482       {
7483         tree type = TREE_TYPE (TREE_OPERAND (t, 0));
7484         if (TREE_CODE (type) == INTEGER_TYPE)
7485           return true;
7486         if (TREE_CODE (type) == REAL_TYPE)
7487           return integer_valued_real_p (TREE_OPERAND (t, 0));
7488         break;
7489       }
7490
7491     case CALL_EXPR:
7492       switch (builtin_mathfn_code (t))
7493         {
7494         CASE_FLT_FN (BUILT_IN_CEIL):
7495         CASE_FLT_FN (BUILT_IN_FLOOR):
7496         CASE_FLT_FN (BUILT_IN_NEARBYINT):
7497         CASE_FLT_FN (BUILT_IN_RINT):
7498         CASE_FLT_FN (BUILT_IN_ROUND):
7499         CASE_FLT_FN (BUILT_IN_TRUNC):
7500           return true;
7501
7502         CASE_FLT_FN (BUILT_IN_FMIN):
7503         CASE_FLT_FN (BUILT_IN_FMAX):
7504           return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
7505             && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
7506
7507         default:
7508           break;
7509         }
7510       break;
7511
7512     default:
7513       break;
7514     }
7515   return false;
7516 }
7517
7518 /* FNDECL is assumed to be a builtin where truncation can be propagated
7519    across (for instance floor((double)f) == (double)floorf (f).
7520    Do the transformation for a call with argument ARG.  */
7521
7522 static tree
7523 fold_trunc_transparent_mathfn (tree fndecl, tree arg)
7524 {
7525   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7526
7527   if (!validate_arg (arg, REAL_TYPE))
7528     return NULL_TREE;
7529
7530   /* Integer rounding functions are idempotent.  */
7531   if (fcode == builtin_mathfn_code (arg))
7532     return arg;
7533
7534   /* If argument is already integer valued, and we don't need to worry
7535      about setting errno, there's no need to perform rounding.  */
7536   if (! flag_errno_math && integer_valued_real_p (arg))
7537     return arg;
7538
7539   if (optimize)
7540     {
7541       tree arg0 = strip_float_extensions (arg);
7542       tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
7543       tree newtype = TREE_TYPE (arg0);
7544       tree decl;
7545
7546       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7547           && (decl = mathfn_built_in (newtype, fcode)))
7548         return fold_convert (ftype,
7549                              build_call_expr (decl, 1,
7550                                               fold_convert (newtype, arg0)));
7551     }
7552   return NULL_TREE;
7553 }
7554
7555 /* FNDECL is assumed to be builtin which can narrow the FP type of
7556    the argument, for instance lround((double)f) -> lroundf (f).
7557    Do the transformation for a call with argument ARG.  */
7558
7559 static tree
7560 fold_fixed_mathfn (tree fndecl, tree arg)
7561 {
7562   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7563
7564   if (!validate_arg (arg, REAL_TYPE))
7565     return NULL_TREE;
7566
7567   /* If argument is already integer valued, and we don't need to worry
7568      about setting errno, there's no need to perform rounding.  */
7569   if (! flag_errno_math && integer_valued_real_p (arg))
7570     return fold_build1 (FIX_TRUNC_EXPR, TREE_TYPE (TREE_TYPE (fndecl)), arg);
7571
7572   if (optimize)
7573     {
7574       tree ftype = TREE_TYPE (arg);
7575       tree arg0 = strip_float_extensions (arg);
7576       tree newtype = TREE_TYPE (arg0);
7577       tree decl;
7578
7579       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7580           && (decl = mathfn_built_in (newtype, fcode)))
7581         return build_call_expr (decl, 1, fold_convert (newtype, arg0));
7582     }
7583
7584   /* Canonicalize llround (x) to lround (x) on LP64 targets where
7585      sizeof (long long) == sizeof (long).  */
7586   if (TYPE_PRECISION (long_long_integer_type_node)
7587       == TYPE_PRECISION (long_integer_type_node))
7588     {
7589       tree newfn = NULL_TREE;
7590       switch (fcode)
7591         {
7592         CASE_FLT_FN (BUILT_IN_LLCEIL):
7593           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
7594           break;
7595
7596         CASE_FLT_FN (BUILT_IN_LLFLOOR):
7597           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
7598           break;
7599
7600         CASE_FLT_FN (BUILT_IN_LLROUND):
7601           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
7602           break;
7603
7604         CASE_FLT_FN (BUILT_IN_LLRINT):
7605           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7606           break;
7607
7608         default:
7609           break;
7610         }
7611
7612       if (newfn)
7613         {
7614           tree newcall = build_call_expr(newfn, 1, arg);
7615           return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7616         }
7617     }
7618
7619   return NULL_TREE;
7620 }
7621
7622 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG.  TYPE is the
7623    return type.  Return NULL_TREE if no simplification can be made.  */
7624
7625 static tree
7626 fold_builtin_cabs (tree arg, tree type, tree fndecl)
7627 {
7628   tree res;
7629
7630   if (TREE_CODE (TREE_TYPE (arg)) != COMPLEX_TYPE
7631       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7632     return NULL_TREE;
7633
7634   /* Calculate the result when the argument is a constant.  */
7635   if (TREE_CODE (arg) == COMPLEX_CST
7636       && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7637                               type, mpfr_hypot)))
7638     return res;
7639
7640   if (TREE_CODE (arg) == COMPLEX_EXPR)
7641     {
7642       tree real = TREE_OPERAND (arg, 0);
7643       tree imag = TREE_OPERAND (arg, 1);
7644
7645       /* If either part is zero, cabs is fabs of the other.  */
7646       if (real_zerop (real))
7647         return fold_build1 (ABS_EXPR, type, imag);
7648       if (real_zerop (imag))
7649         return fold_build1 (ABS_EXPR, type, real);
7650
7651       /* cabs(x+xi) -> fabs(x)*sqrt(2).  */
7652       if (flag_unsafe_math_optimizations
7653           && operand_equal_p (real, imag, OEP_PURE_SAME))
7654         {
7655           const REAL_VALUE_TYPE sqrt2_trunc
7656             = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7657           STRIP_NOPS (real);
7658           return fold_build2 (MULT_EXPR, type,
7659                               fold_build1 (ABS_EXPR, type, real),
7660                               build_real (type, sqrt2_trunc));
7661         }
7662     }
7663
7664   /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z).  */
7665   if (TREE_CODE (arg) == NEGATE_EXPR
7666       || TREE_CODE (arg) == CONJ_EXPR)
7667     return build_call_expr (fndecl, 1, TREE_OPERAND (arg, 0));
7668
7669   /* Don't do this when optimizing for size.  */
7670   if (flag_unsafe_math_optimizations
7671       && optimize && optimize_function_for_speed_p (cfun))
7672     {
7673       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7674
7675       if (sqrtfn != NULL_TREE)
7676         {
7677           tree rpart, ipart, result;
7678
7679           arg = builtin_save_expr (arg);
7680
7681           rpart = fold_build1 (REALPART_EXPR, type, arg);
7682           ipart = fold_build1 (IMAGPART_EXPR, type, arg);
7683
7684           rpart = builtin_save_expr (rpart);
7685           ipart = builtin_save_expr (ipart);
7686
7687           result = fold_build2 (PLUS_EXPR, type,
7688                                 fold_build2 (MULT_EXPR, type,
7689                                              rpart, rpart),
7690                                 fold_build2 (MULT_EXPR, type,
7691                                              ipart, ipart));
7692
7693           return build_call_expr (sqrtfn, 1, result);
7694         }
7695     }
7696
7697   return NULL_TREE;
7698 }
7699
7700 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7701    Return NULL_TREE if no simplification can be made.  */
7702
7703 static tree
7704 fold_builtin_sqrt (tree arg, tree type)
7705 {
7706
7707   enum built_in_function fcode;
7708   tree res;
7709
7710   if (!validate_arg (arg, REAL_TYPE))
7711     return NULL_TREE;
7712
7713   /* Calculate the result when the argument is a constant.  */
7714   if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7715     return res;
7716
7717   /* Optimize sqrt(expN(x)) = expN(x*0.5).  */
7718   fcode = builtin_mathfn_code (arg);
7719   if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7720     {
7721       tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7722       arg = fold_build2 (MULT_EXPR, type,
7723                          CALL_EXPR_ARG (arg, 0),
7724                          build_real (type, dconsthalf));
7725       return build_call_expr (expfn, 1, arg);
7726     }
7727
7728   /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)).  */
7729   if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7730     {
7731       tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7732
7733       if (powfn)
7734         {
7735           tree arg0 = CALL_EXPR_ARG (arg, 0);
7736           tree tree_root;
7737           /* The inner root was either sqrt or cbrt.  */
7738           /* This was a conditional expression but it triggered a bug
7739              in Sun C 5.5.  */
7740           REAL_VALUE_TYPE dconstroot;
7741           if (BUILTIN_SQRT_P (fcode))
7742             dconstroot = dconsthalf;
7743           else
7744             dconstroot = dconst_third ();
7745
7746           /* Adjust for the outer root.  */
7747           SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7748           dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7749           tree_root = build_real (type, dconstroot);
7750           return build_call_expr (powfn, 2, arg0, tree_root);
7751         }
7752     }
7753
7754   /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5).  */
7755   if (flag_unsafe_math_optimizations
7756       && (fcode == BUILT_IN_POW
7757           || fcode == BUILT_IN_POWF
7758           || fcode == BUILT_IN_POWL))
7759     {
7760       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7761       tree arg0 = CALL_EXPR_ARG (arg, 0);
7762       tree arg1 = CALL_EXPR_ARG (arg, 1);
7763       tree narg1;
7764       if (!tree_expr_nonnegative_p (arg0))
7765         arg0 = build1 (ABS_EXPR, type, arg0);
7766       narg1 = fold_build2 (MULT_EXPR, type, arg1,
7767                            build_real (type, dconsthalf));
7768       return build_call_expr (powfn, 2, arg0, narg1);
7769     }
7770
7771   return NULL_TREE;
7772 }
7773
7774 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7775    Return NULL_TREE if no simplification can be made.  */
7776
7777 static tree
7778 fold_builtin_cbrt (tree arg, tree type)
7779 {
7780   const enum built_in_function fcode = builtin_mathfn_code (arg);
7781   tree res;
7782
7783   if (!validate_arg (arg, REAL_TYPE))
7784     return NULL_TREE;
7785
7786   /* Calculate the result when the argument is a constant.  */
7787   if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7788     return res;
7789
7790   if (flag_unsafe_math_optimizations)
7791     {
7792       /* Optimize cbrt(expN(x)) -> expN(x/3).  */
7793       if (BUILTIN_EXPONENT_P (fcode))
7794         {
7795           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7796           const REAL_VALUE_TYPE third_trunc =
7797             real_value_truncate (TYPE_MODE (type), dconst_third ());
7798           arg = fold_build2 (MULT_EXPR, type,
7799                              CALL_EXPR_ARG (arg, 0),
7800                              build_real (type, third_trunc));
7801           return build_call_expr (expfn, 1, arg);
7802         }
7803
7804       /* Optimize cbrt(sqrt(x)) -> pow(x,1/6).  */
7805       if (BUILTIN_SQRT_P (fcode))
7806         {
7807           tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7808
7809           if (powfn)
7810             {
7811               tree arg0 = CALL_EXPR_ARG (arg, 0);
7812               tree tree_root;
7813               REAL_VALUE_TYPE dconstroot = dconst_third ();
7814
7815               SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7816               dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7817               tree_root = build_real (type, dconstroot);
7818               return build_call_expr (powfn, 2, arg0, tree_root);
7819             }
7820         }
7821
7822       /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative.  */
7823       if (BUILTIN_CBRT_P (fcode))
7824         {
7825           tree arg0 = CALL_EXPR_ARG (arg, 0);
7826           if (tree_expr_nonnegative_p (arg0))
7827             {
7828               tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7829
7830               if (powfn)
7831                 {
7832                   tree tree_root;
7833                   REAL_VALUE_TYPE dconstroot;
7834
7835                   real_arithmetic (&dconstroot, MULT_EXPR,
7836                                    dconst_third_ptr (), dconst_third_ptr ());
7837                   dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7838                   tree_root = build_real (type, dconstroot);
7839                   return build_call_expr (powfn, 2, arg0, tree_root);
7840                 }
7841             }
7842         }
7843
7844       /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative.  */
7845       if (fcode == BUILT_IN_POW
7846           || fcode == BUILT_IN_POWF
7847           || fcode == BUILT_IN_POWL)
7848         {
7849           tree arg00 = CALL_EXPR_ARG (arg, 0);
7850           tree arg01 = CALL_EXPR_ARG (arg, 1);
7851           if (tree_expr_nonnegative_p (arg00))
7852             {
7853               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7854               const REAL_VALUE_TYPE dconstroot
7855                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7856               tree narg01 = fold_build2 (MULT_EXPR, type, arg01,
7857                                          build_real (type, dconstroot));
7858               return build_call_expr (powfn, 2, arg00, narg01);
7859             }
7860         }
7861     }
7862   return NULL_TREE;
7863 }
7864
7865 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7866    TYPE is the type of the return value.  Return NULL_TREE if no
7867    simplification can be made.  */
7868
7869 static tree
7870 fold_builtin_cos (tree arg, tree type, tree fndecl)
7871 {
7872   tree res, narg;
7873
7874   if (!validate_arg (arg, REAL_TYPE))
7875     return NULL_TREE;
7876
7877   /* Calculate the result when the argument is a constant.  */
7878   if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7879     return res;
7880
7881   /* Optimize cos(-x) into cos (x).  */
7882   if ((narg = fold_strip_sign_ops (arg)))
7883     return build_call_expr (fndecl, 1, narg);
7884
7885   return NULL_TREE;
7886 }
7887
7888 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7889    Return NULL_TREE if no simplification can be made.  */
7890
7891 static tree
7892 fold_builtin_cosh (tree arg, tree type, tree fndecl)
7893 {
7894   if (validate_arg (arg, REAL_TYPE))
7895     {
7896       tree res, narg;
7897
7898       /* Calculate the result when the argument is a constant.  */
7899       if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7900         return res;
7901
7902       /* Optimize cosh(-x) into cosh (x).  */
7903       if ((narg = fold_strip_sign_ops (arg)))
7904         return build_call_expr (fndecl, 1, narg);
7905     }
7906
7907   return NULL_TREE;
7908 }
7909
7910 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7911    argument ARG.  TYPE is the type of the return value.  Return
7912    NULL_TREE if no simplification can be made.  */
7913
7914 static tree
7915 fold_builtin_ccos (tree arg, tree type ATTRIBUTE_UNUSED, tree fndecl,
7916                    bool hyper ATTRIBUTE_UNUSED)
7917 {
7918   if (validate_arg (arg, COMPLEX_TYPE)
7919       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7920     {
7921       tree tmp;
7922
7923 #ifdef HAVE_mpc
7924       /* Calculate the result when the argument is a constant.  */
7925       if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7926         return tmp;
7927 #endif
7928
7929       /* Optimize fn(-x) into fn(x).  */
7930       if ((tmp = fold_strip_sign_ops (arg)))
7931         return build_call_expr (fndecl, 1, tmp);
7932     }
7933
7934   return NULL_TREE;
7935 }
7936
7937 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7938    Return NULL_TREE if no simplification can be made.  */
7939
7940 static tree
7941 fold_builtin_tan (tree arg, tree type)
7942 {
7943   enum built_in_function fcode;
7944   tree res;
7945
7946   if (!validate_arg (arg, REAL_TYPE))
7947     return NULL_TREE;
7948
7949   /* Calculate the result when the argument is a constant.  */
7950   if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7951     return res;
7952
7953   /* Optimize tan(atan(x)) = x.  */
7954   fcode = builtin_mathfn_code (arg);
7955   if (flag_unsafe_math_optimizations
7956       && (fcode == BUILT_IN_ATAN
7957           || fcode == BUILT_IN_ATANF
7958           || fcode == BUILT_IN_ATANL))
7959     return CALL_EXPR_ARG (arg, 0);
7960
7961   return NULL_TREE;
7962 }
7963
7964 /* Fold function call to builtin sincos, sincosf, or sincosl.  Return
7965    NULL_TREE if no simplification can be made.  */
7966
7967 static tree
7968 fold_builtin_sincos (tree arg0, tree arg1, tree arg2)
7969 {
7970   tree type;
7971   tree res, fn, call;
7972
7973   if (!validate_arg (arg0, REAL_TYPE)
7974       || !validate_arg (arg1, POINTER_TYPE)
7975       || !validate_arg (arg2, POINTER_TYPE))
7976     return NULL_TREE;
7977
7978   type = TREE_TYPE (arg0);
7979
7980   /* Calculate the result when the argument is a constant.  */
7981   if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7982     return res;
7983
7984   /* Canonicalize sincos to cexpi.  */
7985   if (!TARGET_C99_FUNCTIONS)
7986     return NULL_TREE;
7987   fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7988   if (!fn)
7989     return NULL_TREE;
7990
7991   call = build_call_expr (fn, 1, arg0);
7992   call = builtin_save_expr (call);
7993
7994   return build2 (COMPOUND_EXPR, void_type_node,
7995                  build2 (MODIFY_EXPR, void_type_node,
7996                          build_fold_indirect_ref (arg1),
7997                          build1 (IMAGPART_EXPR, type, call)),
7998                  build2 (MODIFY_EXPR, void_type_node,
7999                          build_fold_indirect_ref (arg2),
8000                          build1 (REALPART_EXPR, type, call)));
8001 }
8002
8003 /* Fold function call to builtin cexp, cexpf, or cexpl.  Return
8004    NULL_TREE if no simplification can be made.  */
8005
8006 static tree
8007 fold_builtin_cexp (tree arg0, tree type)
8008 {
8009   tree rtype;
8010   tree realp, imagp, ifn;
8011 #ifdef HAVE_mpc
8012   tree res;
8013 #endif
8014
8015   if (!validate_arg (arg0, COMPLEX_TYPE)
8016       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
8017     return NULL_TREE;
8018
8019 #ifdef HAVE_mpc
8020   /* Calculate the result when the argument is a constant.  */
8021   if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
8022     return res;
8023 #endif
8024
8025   rtype = TREE_TYPE (TREE_TYPE (arg0));
8026
8027   /* In case we can figure out the real part of arg0 and it is constant zero
8028      fold to cexpi.  */
8029   if (!TARGET_C99_FUNCTIONS)
8030     return NULL_TREE;
8031   ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
8032   if (!ifn)
8033     return NULL_TREE;
8034
8035   if ((realp = fold_unary (REALPART_EXPR, rtype, arg0))
8036       && real_zerop (realp))
8037     {
8038       tree narg = fold_build1 (IMAGPART_EXPR, rtype, arg0);
8039       return build_call_expr (ifn, 1, narg);
8040     }
8041
8042   /* In case we can easily decompose real and imaginary parts split cexp
8043      to exp (r) * cexpi (i).  */
8044   if (flag_unsafe_math_optimizations
8045       && realp)
8046     {
8047       tree rfn, rcall, icall;
8048
8049       rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
8050       if (!rfn)
8051         return NULL_TREE;
8052
8053       imagp = fold_unary (IMAGPART_EXPR, rtype, arg0);
8054       if (!imagp)
8055         return NULL_TREE;
8056
8057       icall = build_call_expr (ifn, 1, imagp);
8058       icall = builtin_save_expr (icall);
8059       rcall = build_call_expr (rfn, 1, realp);
8060       rcall = builtin_save_expr (rcall);
8061       return fold_build2 (COMPLEX_EXPR, type,
8062                           fold_build2 (MULT_EXPR, rtype,
8063                                        rcall,
8064                                        fold_build1 (REALPART_EXPR, rtype, icall)),
8065                           fold_build2 (MULT_EXPR, rtype,
8066                                        rcall,
8067                                        fold_build1 (IMAGPART_EXPR, rtype, icall)));
8068     }
8069
8070   return NULL_TREE;
8071 }
8072
8073 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
8074    Return NULL_TREE if no simplification can be made.  */
8075
8076 static tree
8077 fold_builtin_trunc (tree fndecl, tree arg)
8078 {
8079   if (!validate_arg (arg, REAL_TYPE))
8080     return NULL_TREE;
8081
8082   /* Optimize trunc of constant value.  */
8083   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
8084     {
8085       REAL_VALUE_TYPE r, x;
8086       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8087
8088       x = TREE_REAL_CST (arg);
8089       real_trunc (&r, TYPE_MODE (type), &x);
8090       return build_real (type, r);
8091     }
8092
8093   return fold_trunc_transparent_mathfn (fndecl, arg);
8094 }
8095
8096 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
8097    Return NULL_TREE if no simplification can be made.  */
8098
8099 static tree
8100 fold_builtin_floor (tree fndecl, tree arg)
8101 {
8102   if (!validate_arg (arg, REAL_TYPE))
8103     return NULL_TREE;
8104
8105   /* Optimize floor of constant value.  */
8106   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
8107     {
8108       REAL_VALUE_TYPE x;
8109
8110       x = TREE_REAL_CST (arg);
8111       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
8112         {
8113           tree type = TREE_TYPE (TREE_TYPE (fndecl));
8114           REAL_VALUE_TYPE r;
8115
8116           real_floor (&r, TYPE_MODE (type), &x);
8117           return build_real (type, r);
8118         }
8119     }
8120
8121   /* Fold floor (x) where x is nonnegative to trunc (x).  */
8122   if (tree_expr_nonnegative_p (arg))
8123     {
8124       tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
8125       if (truncfn)
8126         return build_call_expr (truncfn, 1, arg);
8127     }
8128
8129   return fold_trunc_transparent_mathfn (fndecl, arg);
8130 }
8131
8132 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
8133    Return NULL_TREE if no simplification can be made.  */
8134
8135 static tree
8136 fold_builtin_ceil (tree fndecl, tree arg)
8137 {
8138   if (!validate_arg (arg, REAL_TYPE))
8139     return NULL_TREE;
8140
8141   /* Optimize ceil of constant value.  */
8142   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
8143     {
8144       REAL_VALUE_TYPE x;
8145
8146       x = TREE_REAL_CST (arg);
8147       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
8148         {
8149           tree type = TREE_TYPE (TREE_TYPE (fndecl));
8150           REAL_VALUE_TYPE r;
8151
8152           real_ceil (&r, TYPE_MODE (type), &x);
8153           return build_real (type, r);
8154         }
8155     }
8156
8157   return fold_trunc_transparent_mathfn (fndecl, arg);
8158 }
8159
8160 /* Fold function call to builtin round, roundf or roundl with argument ARG.
8161    Return NULL_TREE if no simplification can be made.  */
8162
8163 static tree
8164 fold_builtin_round (tree fndecl, tree arg)
8165 {
8166   if (!validate_arg (arg, REAL_TYPE))
8167     return NULL_TREE;
8168
8169   /* Optimize round of constant value.  */
8170   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
8171     {
8172       REAL_VALUE_TYPE x;
8173
8174       x = TREE_REAL_CST (arg);
8175       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
8176         {
8177           tree type = TREE_TYPE (TREE_TYPE (fndecl));
8178           REAL_VALUE_TYPE r;
8179
8180           real_round (&r, TYPE_MODE (type), &x);
8181           return build_real (type, r);
8182         }
8183     }
8184
8185   return fold_trunc_transparent_mathfn (fndecl, arg);
8186 }
8187
8188 /* Fold function call to builtin lround, lroundf or lroundl (or the
8189    corresponding long long versions) and other rounding functions.  ARG
8190    is the argument to the call.  Return NULL_TREE if no simplification
8191    can be made.  */
8192
8193 static tree
8194 fold_builtin_int_roundingfn (tree fndecl, tree arg)
8195 {
8196   if (!validate_arg (arg, REAL_TYPE))
8197     return NULL_TREE;
8198
8199   /* Optimize lround of constant value.  */
8200   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
8201     {
8202       const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
8203
8204       if (real_isfinite (&x))
8205         {
8206           tree itype = TREE_TYPE (TREE_TYPE (fndecl));
8207           tree ftype = TREE_TYPE (arg);
8208           unsigned HOST_WIDE_INT lo2;
8209           HOST_WIDE_INT hi, lo;
8210           REAL_VALUE_TYPE r;
8211
8212           switch (DECL_FUNCTION_CODE (fndecl))
8213             {
8214             CASE_FLT_FN (BUILT_IN_LFLOOR):
8215             CASE_FLT_FN (BUILT_IN_LLFLOOR):
8216               real_floor (&r, TYPE_MODE (ftype), &x);
8217               break;
8218
8219             CASE_FLT_FN (BUILT_IN_LCEIL):
8220             CASE_FLT_FN (BUILT_IN_LLCEIL):
8221               real_ceil (&r, TYPE_MODE (ftype), &x);
8222               break;
8223
8224             CASE_FLT_FN (BUILT_IN_LROUND):
8225             CASE_FLT_FN (BUILT_IN_LLROUND):
8226               real_round (&r, TYPE_MODE (ftype), &x);
8227               break;
8228
8229             default:
8230               gcc_unreachable ();
8231             }
8232
8233           REAL_VALUE_TO_INT (&lo, &hi, r);
8234           if (!fit_double_type (lo, hi, &lo2, &hi, itype))
8235             return build_int_cst_wide (itype, lo2, hi);
8236         }
8237     }
8238
8239   switch (DECL_FUNCTION_CODE (fndecl))
8240     {
8241     CASE_FLT_FN (BUILT_IN_LFLOOR):
8242     CASE_FLT_FN (BUILT_IN_LLFLOOR):
8243       /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x).  */
8244       if (tree_expr_nonnegative_p (arg))
8245         return fold_build1 (FIX_TRUNC_EXPR, TREE_TYPE (TREE_TYPE (fndecl)),
8246                             arg);
8247       break;
8248     default:;
8249     }
8250
8251   return fold_fixed_mathfn (fndecl, arg);
8252 }
8253
8254 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
8255    and their long and long long variants (i.e. ffsl and ffsll).  ARG is
8256    the argument to the call.  Return NULL_TREE if no simplification can
8257    be made.  */
8258
8259 static tree
8260 fold_builtin_bitop (tree fndecl, tree arg)
8261 {
8262   if (!validate_arg (arg, INTEGER_TYPE))
8263     return NULL_TREE;
8264
8265   /* Optimize for constant argument.  */
8266   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
8267     {
8268       HOST_WIDE_INT hi, width, result;
8269       unsigned HOST_WIDE_INT lo;
8270       tree type;
8271
8272       type = TREE_TYPE (arg);
8273       width = TYPE_PRECISION (type);
8274       lo = TREE_INT_CST_LOW (arg);
8275
8276       /* Clear all the bits that are beyond the type's precision.  */
8277       if (width > HOST_BITS_PER_WIDE_INT)
8278         {
8279           hi = TREE_INT_CST_HIGH (arg);
8280           if (width < 2 * HOST_BITS_PER_WIDE_INT)
8281             hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
8282         }
8283       else
8284         {
8285           hi = 0;
8286           if (width < HOST_BITS_PER_WIDE_INT)
8287             lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
8288         }
8289
8290       switch (DECL_FUNCTION_CODE (fndecl))
8291         {
8292         CASE_INT_FN (BUILT_IN_FFS):
8293           if (lo != 0)
8294             result = exact_log2 (lo & -lo) + 1;
8295           else if (hi != 0)
8296             result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi) + 1;
8297           else
8298             result = 0;
8299           break;
8300
8301         CASE_INT_FN (BUILT_IN_CLZ):
8302           if (hi != 0)
8303             result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
8304           else if (lo != 0)
8305             result = width - floor_log2 (lo) - 1;
8306           else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
8307             result = width;
8308           break;
8309
8310         CASE_INT_FN (BUILT_IN_CTZ):
8311           if (lo != 0)
8312             result = exact_log2 (lo & -lo);
8313           else if (hi != 0)
8314             result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi);
8315           else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
8316             result = width;
8317           break;
8318
8319         CASE_INT_FN (BUILT_IN_POPCOUNT):
8320           result = 0;
8321           while (lo)
8322             result++, lo &= lo - 1;
8323           while (hi)
8324             result++, hi &= hi - 1;
8325           break;
8326
8327         CASE_INT_FN (BUILT_IN_PARITY):
8328           result = 0;
8329           while (lo)
8330             result++, lo &= lo - 1;
8331           while (hi)
8332             result++, hi &= hi - 1;
8333           result &= 1;
8334           break;
8335
8336         default:
8337           gcc_unreachable ();
8338         }
8339
8340       return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
8341     }
8342
8343   return NULL_TREE;
8344 }
8345
8346 /* Fold function call to builtin_bswap and the long and long long
8347    variants.  Return NULL_TREE if no simplification can be made.  */
8348 static tree
8349 fold_builtin_bswap (tree fndecl, tree arg)
8350 {
8351   if (! validate_arg (arg, INTEGER_TYPE))
8352     return NULL_TREE;
8353
8354   /* Optimize constant value.  */
8355   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
8356     {
8357       HOST_WIDE_INT hi, width, r_hi = 0;
8358       unsigned HOST_WIDE_INT lo, r_lo = 0;
8359       tree type;
8360
8361       type = TREE_TYPE (arg);
8362       width = TYPE_PRECISION (type);
8363       lo = TREE_INT_CST_LOW (arg);
8364       hi = TREE_INT_CST_HIGH (arg);
8365
8366       switch (DECL_FUNCTION_CODE (fndecl))
8367         {
8368           case BUILT_IN_BSWAP32:
8369           case BUILT_IN_BSWAP64:
8370             {
8371               int s;
8372
8373               for (s = 0; s < width; s += 8)
8374                 {
8375                   int d = width - s - 8;
8376                   unsigned HOST_WIDE_INT byte;
8377
8378                   if (s < HOST_BITS_PER_WIDE_INT)
8379                     byte = (lo >> s) & 0xff;
8380                   else
8381                     byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
8382
8383                   if (d < HOST_BITS_PER_WIDE_INT)
8384                     r_lo |= byte << d;
8385                   else
8386                     r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
8387                 }
8388             }
8389
8390             break;
8391
8392         default:
8393           gcc_unreachable ();
8394         }
8395
8396       if (width < HOST_BITS_PER_WIDE_INT)
8397         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
8398       else
8399         return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
8400     }
8401
8402   return NULL_TREE;
8403 }
8404
8405 /* A subroutine of fold_builtin to fold the various logarithmic
8406    functions.  Return NULL_TREE if no simplification can me made.
8407    FUNC is the corresponding MPFR logarithm function.  */
8408
8409 static tree
8410 fold_builtin_logarithm (tree fndecl, tree arg,
8411                         int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8412 {
8413   if (validate_arg (arg, REAL_TYPE))
8414     {
8415       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8416       tree res;
8417       const enum built_in_function fcode = builtin_mathfn_code (arg);
8418
8419       /* Calculate the result when the argument is a constant.  */
8420       if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
8421         return res;
8422
8423       /* Special case, optimize logN(expN(x)) = x.  */
8424       if (flag_unsafe_math_optimizations
8425           && ((func == mpfr_log
8426                && (fcode == BUILT_IN_EXP
8427                    || fcode == BUILT_IN_EXPF
8428                    || fcode == BUILT_IN_EXPL))
8429               || (func == mpfr_log2
8430                   && (fcode == BUILT_IN_EXP2
8431                       || fcode == BUILT_IN_EXP2F
8432                       || fcode == BUILT_IN_EXP2L))
8433               || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
8434         return fold_convert (type, CALL_EXPR_ARG (arg, 0));
8435
8436       /* Optimize logN(func()) for various exponential functions.  We
8437          want to determine the value "x" and the power "exponent" in
8438          order to transform logN(x**exponent) into exponent*logN(x).  */
8439       if (flag_unsafe_math_optimizations)
8440         {
8441           tree exponent = 0, x = 0;
8442
8443           switch (fcode)
8444           {
8445           CASE_FLT_FN (BUILT_IN_EXP):
8446             /* Prepare to do logN(exp(exponent) -> exponent*logN(e).  */
8447             x = build_real (type, real_value_truncate (TYPE_MODE (type),
8448                                                        dconst_e ()));
8449             exponent = CALL_EXPR_ARG (arg, 0);
8450             break;
8451           CASE_FLT_FN (BUILT_IN_EXP2):
8452             /* Prepare to do logN(exp2(exponent) -> exponent*logN(2).  */
8453             x = build_real (type, dconst2);
8454             exponent = CALL_EXPR_ARG (arg, 0);
8455             break;
8456           CASE_FLT_FN (BUILT_IN_EXP10):
8457           CASE_FLT_FN (BUILT_IN_POW10):
8458             /* Prepare to do logN(exp10(exponent) -> exponent*logN(10).  */
8459             {
8460               REAL_VALUE_TYPE dconst10;
8461               real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
8462               x = build_real (type, dconst10);
8463             }
8464             exponent = CALL_EXPR_ARG (arg, 0);
8465             break;
8466           CASE_FLT_FN (BUILT_IN_SQRT):
8467             /* Prepare to do logN(sqrt(x) -> 0.5*logN(x).  */
8468             x = CALL_EXPR_ARG (arg, 0);
8469             exponent = build_real (type, dconsthalf);
8470             break;
8471           CASE_FLT_FN (BUILT_IN_CBRT):
8472             /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x).  */
8473             x = CALL_EXPR_ARG (arg, 0);
8474             exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
8475                                                               dconst_third ()));
8476             break;
8477           CASE_FLT_FN (BUILT_IN_POW):
8478             /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x).  */
8479             x = CALL_EXPR_ARG (arg, 0);
8480             exponent = CALL_EXPR_ARG (arg, 1);
8481             break;
8482           default:
8483             break;
8484           }
8485
8486           /* Now perform the optimization.  */
8487           if (x && exponent)
8488             {
8489               tree logfn = build_call_expr (fndecl, 1, x);
8490               return fold_build2 (MULT_EXPR, type, exponent, logfn);
8491             }
8492         }
8493     }
8494
8495   return NULL_TREE;
8496 }
8497
8498 /* Fold a builtin function call to hypot, hypotf, or hypotl.  Return
8499    NULL_TREE if no simplification can be made.  */
8500
8501 static tree
8502 fold_builtin_hypot (tree fndecl, tree arg0, tree arg1, tree type)
8503 {
8504   tree res, narg0, narg1;
8505
8506   if (!validate_arg (arg0, REAL_TYPE)
8507       || !validate_arg (arg1, REAL_TYPE))
8508     return NULL_TREE;
8509
8510   /* Calculate the result when the argument is a constant.  */
8511   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
8512     return res;
8513
8514   /* If either argument to hypot has a negate or abs, strip that off.
8515      E.g. hypot(-x,fabs(y)) -> hypot(x,y).  */
8516   narg0 = fold_strip_sign_ops (arg0);
8517   narg1 = fold_strip_sign_ops (arg1);
8518   if (narg0 || narg1)
8519     {
8520       return build_call_expr (fndecl, 2, narg0 ? narg0 : arg0,
8521                               narg1 ? narg1 : arg1);
8522     }
8523
8524   /* If either argument is zero, hypot is fabs of the other.  */
8525   if (real_zerop (arg0))
8526     return fold_build1 (ABS_EXPR, type, arg1);
8527   else if (real_zerop (arg1))
8528     return fold_build1 (ABS_EXPR, type, arg0);
8529
8530   /* hypot(x,x) -> fabs(x)*sqrt(2).  */
8531   if (flag_unsafe_math_optimizations
8532       && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
8533     {
8534       const REAL_VALUE_TYPE sqrt2_trunc
8535         = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
8536       return fold_build2 (MULT_EXPR, type,
8537                           fold_build1 (ABS_EXPR, type, arg0),
8538                           build_real (type, sqrt2_trunc));
8539     }
8540
8541   return NULL_TREE;
8542 }
8543
8544
8545 /* Fold a builtin function call to pow, powf, or powl.  Return
8546    NULL_TREE if no simplification can be made.  */
8547 static tree
8548 fold_builtin_pow (tree fndecl, tree arg0, tree arg1, tree type)
8549 {
8550   tree res;
8551
8552   if (!validate_arg (arg0, REAL_TYPE)
8553        || !validate_arg (arg1, REAL_TYPE))
8554     return NULL_TREE;
8555
8556   /* Calculate the result when the argument is a constant.  */
8557   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8558     return res;
8559
8560   /* Optimize pow(1.0,y) = 1.0.  */
8561   if (real_onep (arg0))
8562     return omit_one_operand (type, build_real (type, dconst1), arg1);
8563
8564   if (TREE_CODE (arg1) == REAL_CST
8565       && !TREE_OVERFLOW (arg1))
8566     {
8567       REAL_VALUE_TYPE cint;
8568       REAL_VALUE_TYPE c;
8569       HOST_WIDE_INT n;
8570
8571       c = TREE_REAL_CST (arg1);
8572
8573       /* Optimize pow(x,0.0) = 1.0.  */
8574       if (REAL_VALUES_EQUAL (c, dconst0))
8575         return omit_one_operand (type, build_real (type, dconst1),
8576                                  arg0);
8577
8578       /* Optimize pow(x,1.0) = x.  */
8579       if (REAL_VALUES_EQUAL (c, dconst1))
8580         return arg0;
8581
8582       /* Optimize pow(x,-1.0) = 1.0/x.  */
8583       if (REAL_VALUES_EQUAL (c, dconstm1))
8584         return fold_build2 (RDIV_EXPR, type,
8585                             build_real (type, dconst1), arg0);
8586
8587       /* Optimize pow(x,0.5) = sqrt(x).  */
8588       if (flag_unsafe_math_optimizations
8589           && REAL_VALUES_EQUAL (c, dconsthalf))
8590         {
8591           tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8592
8593           if (sqrtfn != NULL_TREE)
8594             return build_call_expr (sqrtfn, 1, arg0);
8595         }
8596
8597       /* Optimize pow(x,1.0/3.0) = cbrt(x).  */
8598       if (flag_unsafe_math_optimizations)
8599         {
8600           const REAL_VALUE_TYPE dconstroot
8601             = real_value_truncate (TYPE_MODE (type), dconst_third ());
8602
8603           if (REAL_VALUES_EQUAL (c, dconstroot))
8604             {
8605               tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8606               if (cbrtfn != NULL_TREE)
8607                   return build_call_expr (cbrtfn, 1, arg0);
8608             }
8609         }
8610
8611       /* Check for an integer exponent.  */
8612       n = real_to_integer (&c);
8613       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8614       if (real_identical (&c, &cint))
8615         {
8616           /* Attempt to evaluate pow at compile-time, unless this should
8617              raise an exception.  */
8618           if (TREE_CODE (arg0) == REAL_CST
8619               && !TREE_OVERFLOW (arg0)
8620               && (n > 0
8621                   || (!flag_trapping_math && !flag_errno_math)
8622                   || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8623             {
8624               REAL_VALUE_TYPE x;
8625               bool inexact;
8626
8627               x = TREE_REAL_CST (arg0);
8628               inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8629               if (flag_unsafe_math_optimizations || !inexact)
8630                 return build_real (type, x);
8631             }
8632
8633           /* Strip sign ops from even integer powers.  */
8634           if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8635             {
8636               tree narg0 = fold_strip_sign_ops (arg0);
8637               if (narg0)
8638                 return build_call_expr (fndecl, 2, narg0, arg1);
8639             }
8640         }
8641     }
8642
8643   if (flag_unsafe_math_optimizations)
8644     {
8645       const enum built_in_function fcode = builtin_mathfn_code (arg0);
8646
8647       /* Optimize pow(expN(x),y) = expN(x*y).  */
8648       if (BUILTIN_EXPONENT_P (fcode))
8649         {
8650           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8651           tree arg = CALL_EXPR_ARG (arg0, 0);
8652           arg = fold_build2 (MULT_EXPR, type, arg, arg1);
8653           return build_call_expr (expfn, 1, arg);
8654         }
8655
8656       /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
8657       if (BUILTIN_SQRT_P (fcode))
8658         {
8659           tree narg0 = CALL_EXPR_ARG (arg0, 0);
8660           tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
8661                                     build_real (type, dconsthalf));
8662           return build_call_expr (fndecl, 2, narg0, narg1);
8663         }
8664
8665       /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative.  */
8666       if (BUILTIN_CBRT_P (fcode))
8667         {
8668           tree arg = CALL_EXPR_ARG (arg0, 0);
8669           if (tree_expr_nonnegative_p (arg))
8670             {
8671               const REAL_VALUE_TYPE dconstroot
8672                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8673               tree narg1 = fold_build2 (MULT_EXPR, type, arg1,
8674                                         build_real (type, dconstroot));
8675               return build_call_expr (fndecl, 2, arg, narg1);
8676             }
8677         }
8678
8679       /* Optimize pow(pow(x,y),z) = pow(x,y*z).  */
8680       if (fcode == BUILT_IN_POW
8681           || fcode == BUILT_IN_POWF
8682           || fcode == BUILT_IN_POWL)
8683         {
8684           tree arg00 = CALL_EXPR_ARG (arg0, 0);
8685           tree arg01 = CALL_EXPR_ARG (arg0, 1);
8686           tree narg1 = fold_build2 (MULT_EXPR, type, arg01, arg1);
8687           return build_call_expr (fndecl, 2, arg00, narg1);
8688         }
8689     }
8690
8691   return NULL_TREE;
8692 }
8693
8694 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8695    Return NULL_TREE if no simplification can be made.  */
8696 static tree
8697 fold_builtin_powi (tree fndecl ATTRIBUTE_UNUSED,
8698                    tree arg0, tree arg1, tree type)
8699 {
8700   if (!validate_arg (arg0, REAL_TYPE)
8701       || !validate_arg (arg1, INTEGER_TYPE))
8702     return NULL_TREE;
8703
8704   /* Optimize pow(1.0,y) = 1.0.  */
8705   if (real_onep (arg0))
8706     return omit_one_operand (type, build_real (type, dconst1), arg1);
8707
8708   if (host_integerp (arg1, 0))
8709     {
8710       HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8711
8712       /* Evaluate powi at compile-time.  */
8713       if (TREE_CODE (arg0) == REAL_CST
8714           && !TREE_OVERFLOW (arg0))
8715         {
8716           REAL_VALUE_TYPE x;
8717           x = TREE_REAL_CST (arg0);
8718           real_powi (&x, TYPE_MODE (type), &x, c);
8719           return build_real (type, x);
8720         }
8721
8722       /* Optimize pow(x,0) = 1.0.  */
8723       if (c == 0)
8724         return omit_one_operand (type, build_real (type, dconst1),
8725                                  arg0);
8726
8727       /* Optimize pow(x,1) = x.  */
8728       if (c == 1)
8729         return arg0;
8730
8731       /* Optimize pow(x,-1) = 1.0/x.  */
8732       if (c == -1)
8733         return fold_build2 (RDIV_EXPR, type,
8734                            build_real (type, dconst1), arg0);
8735     }
8736
8737   return NULL_TREE;
8738 }
8739
8740 /* A subroutine of fold_builtin to fold the various exponent
8741    functions.  Return NULL_TREE if no simplification can be made.
8742    FUNC is the corresponding MPFR exponent function.  */
8743
8744 static tree
8745 fold_builtin_exponent (tree fndecl, tree arg,
8746                        int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8747 {
8748   if (validate_arg (arg, REAL_TYPE))
8749     {
8750       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8751       tree res;
8752
8753       /* Calculate the result when the argument is a constant.  */
8754       if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8755         return res;
8756
8757       /* Optimize expN(logN(x)) = x.  */
8758       if (flag_unsafe_math_optimizations)
8759         {
8760           const enum built_in_function fcode = builtin_mathfn_code (arg);
8761
8762           if ((func == mpfr_exp
8763                && (fcode == BUILT_IN_LOG
8764                    || fcode == BUILT_IN_LOGF
8765                    || fcode == BUILT_IN_LOGL))
8766               || (func == mpfr_exp2
8767                   && (fcode == BUILT_IN_LOG2
8768                       || fcode == BUILT_IN_LOG2F
8769                       || fcode == BUILT_IN_LOG2L))
8770               || (func == mpfr_exp10
8771                   && (fcode == BUILT_IN_LOG10
8772                       || fcode == BUILT_IN_LOG10F
8773                       || fcode == BUILT_IN_LOG10L)))
8774             return fold_convert (type, CALL_EXPR_ARG (arg, 0));
8775         }
8776     }
8777
8778   return NULL_TREE;
8779 }
8780
8781 /* Return true if VAR is a VAR_DECL or a component thereof.  */
8782
8783 static bool
8784 var_decl_component_p (tree var)
8785 {
8786   tree inner = var;
8787   while (handled_component_p (inner))
8788     inner = TREE_OPERAND (inner, 0);
8789   return SSA_VAR_P (inner);
8790 }
8791
8792 /* Fold function call to builtin memset.  Return
8793    NULL_TREE if no simplification can be made.  */
8794
8795 static tree
8796 fold_builtin_memset (tree dest, tree c, tree len, tree type, bool ignore)
8797 {
8798   tree var, ret, etype;
8799   unsigned HOST_WIDE_INT length, cval;
8800
8801   if (! validate_arg (dest, POINTER_TYPE)
8802       || ! validate_arg (c, INTEGER_TYPE)
8803       || ! validate_arg (len, INTEGER_TYPE))
8804     return NULL_TREE;
8805
8806   if (! host_integerp (len, 1))
8807     return NULL_TREE;
8808
8809   /* If the LEN parameter is zero, return DEST.  */
8810   if (integer_zerop (len))
8811     return omit_one_operand (type, dest, c);
8812
8813   if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
8814     return NULL_TREE;
8815
8816   var = dest;
8817   STRIP_NOPS (var);
8818   if (TREE_CODE (var) != ADDR_EXPR)
8819     return NULL_TREE;
8820
8821   var = TREE_OPERAND (var, 0);
8822   if (TREE_THIS_VOLATILE (var))
8823     return NULL_TREE;
8824
8825   etype = TREE_TYPE (var);
8826   if (TREE_CODE (etype) == ARRAY_TYPE)
8827     etype = TREE_TYPE (etype);
8828
8829   if (!INTEGRAL_TYPE_P (etype)
8830       && !POINTER_TYPE_P (etype))
8831     return NULL_TREE;
8832
8833   if (! var_decl_component_p (var))
8834     return NULL_TREE;
8835
8836   length = tree_low_cst (len, 1);
8837   if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8838       || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8839          < (int) length)
8840     return NULL_TREE;
8841
8842   if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8843     return NULL_TREE;
8844
8845   if (integer_zerop (c))
8846     cval = 0;
8847   else
8848     {
8849       if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8850         return NULL_TREE;
8851
8852       cval = tree_low_cst (c, 1);
8853       cval &= 0xff;
8854       cval |= cval << 8;
8855       cval |= cval << 16;
8856       cval |= (cval << 31) << 1;
8857     }
8858
8859   ret = build_int_cst_type (etype, cval);
8860   var = build_fold_indirect_ref (fold_convert (build_pointer_type (etype),
8861                                                dest));
8862   ret = build2 (MODIFY_EXPR, etype, var, ret);
8863   if (ignore)
8864     return ret;
8865
8866   return omit_one_operand (type, dest, ret);
8867 }
8868
8869 /* Fold function call to builtin memset.  Return
8870    NULL_TREE if no simplification can be made.  */
8871
8872 static tree
8873 fold_builtin_bzero (tree dest, tree size, bool ignore)
8874 {
8875   if (! validate_arg (dest, POINTER_TYPE)
8876       || ! validate_arg (size, INTEGER_TYPE))
8877     return NULL_TREE;
8878
8879   if (!ignore)
8880     return NULL_TREE;
8881
8882   /* New argument list transforming bzero(ptr x, int y) to
8883      memset(ptr x, int 0, size_t y).   This is done this way
8884      so that if it isn't expanded inline, we fallback to
8885      calling bzero instead of memset.  */
8886
8887   return fold_builtin_memset (dest, integer_zero_node,
8888                               fold_convert (sizetype, size),
8889                               void_type_node, ignore);
8890 }
8891
8892 /* Fold function call to builtin mem{{,p}cpy,move}.  Return
8893    NULL_TREE if no simplification can be made.
8894    If ENDP is 0, return DEST (like memcpy).
8895    If ENDP is 1, return DEST+LEN (like mempcpy).
8896    If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8897    If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8898    (memmove).   */
8899
8900 static tree
8901 fold_builtin_memory_op (tree dest, tree src, tree len, tree type, bool ignore, int endp)
8902 {
8903   tree destvar, srcvar, expr;
8904
8905   if (! validate_arg (dest, POINTER_TYPE)
8906       || ! validate_arg (src, POINTER_TYPE)
8907       || ! validate_arg (len, INTEGER_TYPE))
8908     return NULL_TREE;
8909
8910   /* If the LEN parameter is zero, return DEST.  */
8911   if (integer_zerop (len))
8912     return omit_one_operand (type, dest, src);
8913
8914   /* If SRC and DEST are the same (and not volatile), return
8915      DEST{,+LEN,+LEN-1}.  */
8916   if (operand_equal_p (src, dest, 0))
8917     expr = len;
8918   else
8919     {
8920       tree srctype, desttype;
8921       int src_align, dest_align;
8922
8923       if (endp == 3)
8924         {
8925           src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8926           dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8927
8928           /* Both DEST and SRC must be pointer types.
8929              ??? This is what old code did.  Is the testing for pointer types
8930              really mandatory?
8931
8932              If either SRC is readonly or length is 1, we can use memcpy.  */
8933           if (!dest_align || !src_align)
8934             return NULL_TREE;
8935           if (readonly_data_expr (src)
8936               || (host_integerp (len, 1)
8937                   && (MIN (src_align, dest_align) / BITS_PER_UNIT
8938                       >= tree_low_cst (len, 1))))
8939             {
8940               tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8941               if (!fn)
8942                 return NULL_TREE;
8943               return build_call_expr (fn, 3, dest, src, len);
8944             }
8945
8946           /* If *src and *dest can't overlap, optimize into memcpy as well.  */
8947           srcvar = build_fold_indirect_ref (src);
8948           destvar = build_fold_indirect_ref (dest);
8949           if (srcvar
8950               && !TREE_THIS_VOLATILE (srcvar)
8951               && destvar
8952               && !TREE_THIS_VOLATILE (destvar))
8953             {
8954               tree src_base, dest_base, fn;
8955               HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8956               HOST_WIDE_INT size = -1;
8957               HOST_WIDE_INT maxsize = -1;
8958
8959               src_base = srcvar;
8960               if (handled_component_p (src_base))
8961                 src_base = get_ref_base_and_extent (src_base, &src_offset,
8962                                                     &size, &maxsize);
8963               dest_base = destvar;
8964               if (handled_component_p (dest_base))
8965                 dest_base = get_ref_base_and_extent (dest_base, &dest_offset,
8966                                                      &size, &maxsize);
8967               if (host_integerp (len, 1))
8968                 {
8969                   maxsize = tree_low_cst (len, 1);
8970                   if (maxsize
8971                       > INTTYPE_MAXIMUM (HOST_WIDE_INT) / BITS_PER_UNIT)
8972                     maxsize = -1;
8973                   else
8974                     maxsize *= BITS_PER_UNIT;
8975                 }
8976               else
8977                 maxsize = -1;
8978               if (SSA_VAR_P (src_base)
8979                   && SSA_VAR_P (dest_base))
8980                 {
8981                   if (operand_equal_p (src_base, dest_base, 0)
8982                       && ranges_overlap_p (src_offset, maxsize,
8983                                            dest_offset, maxsize))
8984                     return NULL_TREE;
8985                 }
8986               else if (TREE_CODE (src_base) == INDIRECT_REF
8987                        && TREE_CODE (dest_base) == INDIRECT_REF)
8988                 {
8989                   if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8990                                          TREE_OPERAND (dest_base, 0), 0)
8991                       || ranges_overlap_p (src_offset, maxsize,
8992                                            dest_offset, maxsize))
8993                     return NULL_TREE;
8994                 }
8995               else
8996                 return NULL_TREE;
8997
8998               fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8999               if (!fn)
9000                 return NULL_TREE;
9001               return build_call_expr (fn, 3, dest, src, len);
9002             }
9003           return NULL_TREE;
9004         }
9005
9006       if (!host_integerp (len, 0))
9007         return NULL_TREE;
9008       /* FIXME:
9009          This logic lose for arguments like (type *)malloc (sizeof (type)),
9010          since we strip the casts of up to VOID return value from malloc.
9011          Perhaps we ought to inherit type from non-VOID argument here?  */
9012       STRIP_NOPS (src);
9013       STRIP_NOPS (dest);
9014       /* As we fold (void *)(p + CST) to (void *)p + CST undo this here.  */
9015       if (TREE_CODE (src) == POINTER_PLUS_EXPR)
9016         {
9017           tree tem = TREE_OPERAND (src, 0);
9018           STRIP_NOPS (tem);
9019           if (tem != TREE_OPERAND (src, 0))
9020             src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
9021         }
9022       if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
9023         {
9024           tree tem = TREE_OPERAND (dest, 0);
9025           STRIP_NOPS (tem);
9026           if (tem != TREE_OPERAND (dest, 0))
9027             dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
9028         }
9029       srctype = TREE_TYPE (TREE_TYPE (src));
9030       if (srctype
9031           && TREE_CODE (srctype) == ARRAY_TYPE
9032           && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
9033         {
9034           srctype = TREE_TYPE (srctype);
9035           STRIP_NOPS (src);
9036           src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
9037         }
9038       desttype = TREE_TYPE (TREE_TYPE (dest));
9039       if (desttype
9040           && TREE_CODE (desttype) == ARRAY_TYPE
9041           && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
9042         {
9043           desttype = TREE_TYPE (desttype);
9044           STRIP_NOPS (dest);
9045           dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
9046         }
9047       if (!srctype || !desttype
9048           || !TYPE_SIZE_UNIT (srctype)
9049           || !TYPE_SIZE_UNIT (desttype)
9050           || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
9051           || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST
9052           || TYPE_VOLATILE (srctype)
9053           || TYPE_VOLATILE (desttype))
9054         return NULL_TREE;
9055
9056       src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
9057       dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
9058       if (dest_align < (int) TYPE_ALIGN (desttype)
9059           || src_align < (int) TYPE_ALIGN (srctype))
9060         return NULL_TREE;
9061
9062       if (!ignore)
9063         dest = builtin_save_expr (dest);
9064
9065       srcvar = NULL_TREE;
9066       if (tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
9067         {
9068           srcvar = build_fold_indirect_ref (src);
9069           if (TREE_THIS_VOLATILE (srcvar))
9070             return NULL_TREE;
9071           else if (!tree_int_cst_equal (lang_hooks.expr_size (srcvar), len))
9072             srcvar = NULL_TREE;
9073           /* With memcpy, it is possible to bypass aliasing rules, so without
9074              this check i.e. execute/20060930-2.c would be misoptimized,
9075              because it use conflicting alias set to hold argument for the
9076              memcpy call.  This check is probably unnecessary with
9077              -fno-strict-aliasing.  Similarly for destvar.  See also
9078              PR29286.  */
9079           else if (!var_decl_component_p (srcvar))
9080             srcvar = NULL_TREE;
9081         }
9082
9083       destvar = NULL_TREE;
9084       if (tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
9085         {
9086           destvar = build_fold_indirect_ref (dest);
9087           if (TREE_THIS_VOLATILE (destvar))
9088             return NULL_TREE;
9089           else if (!tree_int_cst_equal (lang_hooks.expr_size (destvar), len))
9090             destvar = NULL_TREE;
9091           else if (!var_decl_component_p (destvar))
9092             destvar = NULL_TREE;
9093         }
9094
9095       if (srcvar == NULL_TREE && destvar == NULL_TREE)
9096         return NULL_TREE;
9097
9098       if (srcvar == NULL_TREE)
9099         {
9100           tree srcptype;
9101           if (TREE_ADDRESSABLE (TREE_TYPE (destvar)))
9102             return NULL_TREE;
9103
9104           srctype = build_qualified_type (desttype, 0);
9105           if (src_align < (int) TYPE_ALIGN (srctype))
9106             {
9107               if (AGGREGATE_TYPE_P (srctype)
9108                   || SLOW_UNALIGNED_ACCESS (TYPE_MODE (srctype), src_align))
9109                 return NULL_TREE;
9110
9111               srctype = build_variant_type_copy (srctype);
9112               TYPE_ALIGN (srctype) = src_align;
9113               TYPE_USER_ALIGN (srctype) = 1;
9114               TYPE_PACKED (srctype) = 1;
9115             }
9116           srcptype = build_pointer_type_for_mode (srctype, ptr_mode, true);
9117           src = fold_convert (srcptype, src);
9118           srcvar = build_fold_indirect_ref (src);
9119         }
9120       else if (destvar == NULL_TREE)
9121         {
9122           tree destptype;
9123           if (TREE_ADDRESSABLE (TREE_TYPE (srcvar)))
9124             return NULL_TREE;
9125
9126           desttype = build_qualified_type (srctype, 0);
9127           if (dest_align < (int) TYPE_ALIGN (desttype))
9128             {
9129               if (AGGREGATE_TYPE_P (desttype)
9130                   || SLOW_UNALIGNED_ACCESS (TYPE_MODE (desttype), dest_align))
9131                 return NULL_TREE;
9132
9133               desttype = build_variant_type_copy (desttype);
9134               TYPE_ALIGN (desttype) = dest_align;
9135               TYPE_USER_ALIGN (desttype) = 1;
9136               TYPE_PACKED (desttype) = 1;
9137             }
9138           destptype = build_pointer_type_for_mode (desttype, ptr_mode, true);
9139           dest = fold_convert (destptype, dest);
9140           destvar = build_fold_indirect_ref (dest);
9141         }
9142
9143       if (srctype == desttype
9144           || (gimple_in_ssa_p (cfun)
9145               && useless_type_conversion_p (desttype, srctype)))
9146         expr = srcvar;
9147       else if ((INTEGRAL_TYPE_P (TREE_TYPE (srcvar))
9148            || POINTER_TYPE_P (TREE_TYPE (srcvar)))
9149           && (INTEGRAL_TYPE_P (TREE_TYPE (destvar))
9150               || POINTER_TYPE_P (TREE_TYPE (destvar))))
9151         expr = fold_convert (TREE_TYPE (destvar), srcvar);
9152       else
9153         expr = fold_build1 (VIEW_CONVERT_EXPR, TREE_TYPE (destvar), srcvar);
9154       expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, expr);
9155     }
9156
9157   if (ignore)
9158     return expr;
9159
9160   if (endp == 0 || endp == 3)
9161     return omit_one_operand (type, dest, expr);
9162
9163   if (expr == len)
9164     expr = NULL_TREE;
9165
9166   if (endp == 2)
9167     len = fold_build2 (MINUS_EXPR, TREE_TYPE (len), len,
9168                        ssize_int (1));
9169
9170   len = fold_convert (sizetype, len);
9171   dest = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
9172   dest = fold_convert (type, dest);
9173   if (expr)
9174     dest = omit_one_operand (type, dest, expr);
9175   return dest;
9176 }
9177
9178 /* Fold function call to builtin strcpy with arguments DEST and SRC.
9179    If LEN is not NULL, it represents the length of the string to be
9180    copied.  Return NULL_TREE if no simplification can be made.  */
9181
9182 tree
9183 fold_builtin_strcpy (tree fndecl, tree dest, tree src, tree len)
9184 {
9185   tree fn;
9186
9187   if (!validate_arg (dest, POINTER_TYPE)
9188       || !validate_arg (src, POINTER_TYPE))
9189     return NULL_TREE;
9190
9191   /* If SRC and DEST are the same (and not volatile), return DEST.  */
9192   if (operand_equal_p (src, dest, 0))
9193     return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
9194
9195   if (optimize_function_for_size_p (cfun))
9196     return NULL_TREE;
9197
9198   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
9199   if (!fn)
9200     return NULL_TREE;
9201
9202   if (!len)
9203     {
9204       len = c_strlen (src, 1);
9205       if (! len || TREE_SIDE_EFFECTS (len))
9206         return NULL_TREE;
9207     }
9208
9209   len = size_binop (PLUS_EXPR, len, ssize_int (1));
9210   return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
9211                        build_call_expr (fn, 3, dest, src, len));
9212 }
9213
9214 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
9215    If SLEN is not NULL, it represents the length of the source string.
9216    Return NULL_TREE if no simplification can be made.  */
9217
9218 tree
9219 fold_builtin_strncpy (tree fndecl, tree dest, tree src, tree len, tree slen)
9220 {
9221   tree fn;
9222
9223   if (!validate_arg (dest, POINTER_TYPE)
9224       || !validate_arg (src, POINTER_TYPE)
9225       || !validate_arg (len, INTEGER_TYPE))
9226     return NULL_TREE;
9227
9228   /* If the LEN parameter is zero, return DEST.  */
9229   if (integer_zerop (len))
9230     return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
9231
9232   /* We can't compare slen with len as constants below if len is not a
9233      constant.  */
9234   if (len == 0 || TREE_CODE (len) != INTEGER_CST)
9235     return NULL_TREE;
9236
9237   if (!slen)
9238     slen = c_strlen (src, 1);
9239
9240   /* Now, we must be passed a constant src ptr parameter.  */
9241   if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
9242     return NULL_TREE;
9243
9244   slen = size_binop (PLUS_EXPR, slen, ssize_int (1));
9245
9246   /* We do not support simplification of this case, though we do
9247      support it when expanding trees into RTL.  */
9248   /* FIXME: generate a call to __builtin_memset.  */
9249   if (tree_int_cst_lt (slen, len))
9250     return NULL_TREE;
9251
9252   /* OK transform into builtin memcpy.  */
9253   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
9254   if (!fn)
9255     return NULL_TREE;
9256   return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
9257                        build_call_expr (fn, 3, dest, src, len));
9258 }
9259
9260 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
9261    arguments to the call, and TYPE is its return type.
9262    Return NULL_TREE if no simplification can be made.  */
9263
9264 static tree
9265 fold_builtin_memchr (tree arg1, tree arg2, tree len, tree type)
9266 {
9267   if (!validate_arg (arg1, POINTER_TYPE)
9268       || !validate_arg (arg2, INTEGER_TYPE)
9269       || !validate_arg (len, INTEGER_TYPE))
9270     return NULL_TREE;
9271   else
9272     {
9273       const char *p1;
9274
9275       if (TREE_CODE (arg2) != INTEGER_CST
9276           || !host_integerp (len, 1))
9277         return NULL_TREE;
9278
9279       p1 = c_getstr (arg1);
9280       if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
9281         {
9282           char c;
9283           const char *r;
9284           tree tem;
9285
9286           if (target_char_cast (arg2, &c))
9287             return NULL_TREE;
9288
9289           r = (char *) memchr (p1, c, tree_low_cst (len, 1));
9290
9291           if (r == NULL)
9292             return build_int_cst (TREE_TYPE (arg1), 0);
9293
9294           tem = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
9295                              size_int (r - p1));
9296           return fold_convert (type, tem);
9297         }
9298       return NULL_TREE;
9299     }
9300 }
9301
9302 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
9303    Return NULL_TREE if no simplification can be made.  */
9304
9305 static tree
9306 fold_builtin_memcmp (tree arg1, tree arg2, tree len)
9307 {
9308   const char *p1, *p2;
9309
9310   if (!validate_arg (arg1, POINTER_TYPE)
9311       || !validate_arg (arg2, POINTER_TYPE)
9312       || !validate_arg (len, INTEGER_TYPE))
9313     return NULL_TREE;
9314
9315   /* If the LEN parameter is zero, return zero.  */
9316   if (integer_zerop (len))
9317     return omit_two_operands (integer_type_node, integer_zero_node,
9318                               arg1, arg2);
9319
9320   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
9321   if (operand_equal_p (arg1, arg2, 0))
9322     return omit_one_operand (integer_type_node, integer_zero_node, len);
9323
9324   p1 = c_getstr (arg1);
9325   p2 = c_getstr (arg2);
9326
9327   /* If all arguments are constant, and the value of len is not greater
9328      than the lengths of arg1 and arg2, evaluate at compile-time.  */
9329   if (host_integerp (len, 1) && p1 && p2
9330       && compare_tree_int (len, strlen (p1) + 1) <= 0
9331       && compare_tree_int (len, strlen (p2) + 1) <= 0)
9332     {
9333       const int r = memcmp (p1, p2, tree_low_cst (len, 1));
9334
9335       if (r > 0)
9336         return integer_one_node;
9337       else if (r < 0)
9338         return integer_minus_one_node;
9339       else
9340         return integer_zero_node;
9341     }
9342
9343   /* If len parameter is one, return an expression corresponding to
9344      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
9345   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9346     {
9347       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9348       tree cst_uchar_ptr_node
9349         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9350
9351       tree ind1 = fold_convert (integer_type_node,
9352                                 build1 (INDIRECT_REF, cst_uchar_node,
9353                                         fold_convert (cst_uchar_ptr_node,
9354                                                       arg1)));
9355       tree ind2 = fold_convert (integer_type_node,
9356                                 build1 (INDIRECT_REF, cst_uchar_node,
9357                                         fold_convert (cst_uchar_ptr_node,
9358                                                       arg2)));
9359       return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
9360     }
9361
9362   return NULL_TREE;
9363 }
9364
9365 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
9366    Return NULL_TREE if no simplification can be made.  */
9367
9368 static tree
9369 fold_builtin_strcmp (tree arg1, tree arg2)
9370 {
9371   const char *p1, *p2;
9372
9373   if (!validate_arg (arg1, POINTER_TYPE)
9374       || !validate_arg (arg2, POINTER_TYPE))
9375     return NULL_TREE;
9376
9377   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
9378   if (operand_equal_p (arg1, arg2, 0))
9379     return integer_zero_node;
9380
9381   p1 = c_getstr (arg1);
9382   p2 = c_getstr (arg2);
9383
9384   if (p1 && p2)
9385     {
9386       const int i = strcmp (p1, p2);
9387       if (i < 0)
9388         return integer_minus_one_node;
9389       else if (i > 0)
9390         return integer_one_node;
9391       else
9392         return integer_zero_node;
9393     }
9394
9395   /* If the second arg is "", return *(const unsigned char*)arg1.  */
9396   if (p2 && *p2 == '\0')
9397     {
9398       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9399       tree cst_uchar_ptr_node
9400         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9401
9402       return fold_convert (integer_type_node,
9403                            build1 (INDIRECT_REF, cst_uchar_node,
9404                                    fold_convert (cst_uchar_ptr_node,
9405                                                  arg1)));
9406     }
9407
9408   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
9409   if (p1 && *p1 == '\0')
9410     {
9411       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9412       tree cst_uchar_ptr_node
9413         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9414
9415       tree temp = fold_convert (integer_type_node,
9416                                 build1 (INDIRECT_REF, cst_uchar_node,
9417                                         fold_convert (cst_uchar_ptr_node,
9418                                                       arg2)));
9419       return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
9420     }
9421
9422   return NULL_TREE;
9423 }
9424
9425 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
9426    Return NULL_TREE if no simplification can be made.  */
9427
9428 static tree
9429 fold_builtin_strncmp (tree arg1, tree arg2, tree len)
9430 {
9431   const char *p1, *p2;
9432
9433   if (!validate_arg (arg1, POINTER_TYPE)
9434       || !validate_arg (arg2, POINTER_TYPE)
9435       || !validate_arg (len, INTEGER_TYPE))
9436     return NULL_TREE;
9437
9438   /* If the LEN parameter is zero, return zero.  */
9439   if (integer_zerop (len))
9440     return omit_two_operands (integer_type_node, integer_zero_node,
9441                               arg1, arg2);
9442
9443   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
9444   if (operand_equal_p (arg1, arg2, 0))
9445     return omit_one_operand (integer_type_node, integer_zero_node, len);
9446
9447   p1 = c_getstr (arg1);
9448   p2 = c_getstr (arg2);
9449
9450   if (host_integerp (len, 1) && p1 && p2)
9451     {
9452       const int i = strncmp (p1, p2, tree_low_cst (len, 1));
9453       if (i > 0)
9454         return integer_one_node;
9455       else if (i < 0)
9456         return integer_minus_one_node;
9457       else
9458         return integer_zero_node;
9459     }
9460
9461   /* If the second arg is "", and the length is greater than zero,
9462      return *(const unsigned char*)arg1.  */
9463   if (p2 && *p2 == '\0'
9464       && TREE_CODE (len) == INTEGER_CST
9465       && tree_int_cst_sgn (len) == 1)
9466     {
9467       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9468       tree cst_uchar_ptr_node
9469         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9470
9471       return fold_convert (integer_type_node,
9472                            build1 (INDIRECT_REF, cst_uchar_node,
9473                                    fold_convert (cst_uchar_ptr_node,
9474                                                  arg1)));
9475     }
9476
9477   /* If the first arg is "", and the length is greater than zero,
9478      return -*(const unsigned char*)arg2.  */
9479   if (p1 && *p1 == '\0'
9480       && TREE_CODE (len) == INTEGER_CST
9481       && tree_int_cst_sgn (len) == 1)
9482     {
9483       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9484       tree cst_uchar_ptr_node
9485         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9486
9487       tree temp = fold_convert (integer_type_node,
9488                                 build1 (INDIRECT_REF, cst_uchar_node,
9489                                         fold_convert (cst_uchar_ptr_node,
9490                                                       arg2)));
9491       return fold_build1 (NEGATE_EXPR, integer_type_node, temp);
9492     }
9493
9494   /* If len parameter is one, return an expression corresponding to
9495      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
9496   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9497     {
9498       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9499       tree cst_uchar_ptr_node
9500         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9501
9502       tree ind1 = fold_convert (integer_type_node,
9503                                 build1 (INDIRECT_REF, cst_uchar_node,
9504                                         fold_convert (cst_uchar_ptr_node,
9505                                                       arg1)));
9506       tree ind2 = fold_convert (integer_type_node,
9507                                 build1 (INDIRECT_REF, cst_uchar_node,
9508                                         fold_convert (cst_uchar_ptr_node,
9509                                                       arg2)));
9510       return fold_build2 (MINUS_EXPR, integer_type_node, ind1, ind2);
9511     }
9512
9513   return NULL_TREE;
9514 }
9515
9516 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9517    ARG.  Return NULL_TREE if no simplification can be made.  */
9518
9519 static tree
9520 fold_builtin_signbit (tree arg, tree type)
9521 {
9522   tree temp;
9523
9524   if (!validate_arg (arg, REAL_TYPE))
9525     return NULL_TREE;
9526
9527   /* If ARG is a compile-time constant, determine the result.  */
9528   if (TREE_CODE (arg) == REAL_CST
9529       && !TREE_OVERFLOW (arg))
9530     {
9531       REAL_VALUE_TYPE c;
9532
9533       c = TREE_REAL_CST (arg);
9534       temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
9535       return fold_convert (type, temp);
9536     }
9537
9538   /* If ARG is non-negative, the result is always zero.  */
9539   if (tree_expr_nonnegative_p (arg))
9540     return omit_one_operand (type, integer_zero_node, arg);
9541
9542   /* If ARG's format doesn't have signed zeros, return "arg < 0.0".  */
9543   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9544     return fold_build2 (LT_EXPR, type, arg,
9545                         build_real (TREE_TYPE (arg), dconst0));
9546
9547   return NULL_TREE;
9548 }
9549
9550 /* Fold function call to builtin copysign, copysignf or copysignl with
9551    arguments ARG1 and ARG2.  Return NULL_TREE if no simplification can
9552    be made.  */
9553
9554 static tree
9555 fold_builtin_copysign (tree fndecl, tree arg1, tree arg2, tree type)
9556 {
9557   tree tem;
9558
9559   if (!validate_arg (arg1, REAL_TYPE)
9560       || !validate_arg (arg2, REAL_TYPE))
9561     return NULL_TREE;
9562
9563   /* copysign(X,X) is X.  */
9564   if (operand_equal_p (arg1, arg2, 0))
9565     return fold_convert (type, arg1);
9566
9567   /* If ARG1 and ARG2 are compile-time constants, determine the result.  */
9568   if (TREE_CODE (arg1) == REAL_CST
9569       && TREE_CODE (arg2) == REAL_CST
9570       && !TREE_OVERFLOW (arg1)
9571       && !TREE_OVERFLOW (arg2))
9572     {
9573       REAL_VALUE_TYPE c1, c2;
9574
9575       c1 = TREE_REAL_CST (arg1);
9576       c2 = TREE_REAL_CST (arg2);
9577       /* c1.sign := c2.sign.  */
9578       real_copysign (&c1, &c2);
9579       return build_real (type, c1);
9580     }
9581
9582   /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9583      Remember to evaluate Y for side-effects.  */
9584   if (tree_expr_nonnegative_p (arg2))
9585     return omit_one_operand (type,
9586                              fold_build1 (ABS_EXPR, type, arg1),
9587                              arg2);
9588
9589   /* Strip sign changing operations for the first argument.  */
9590   tem = fold_strip_sign_ops (arg1);
9591   if (tem)
9592     return build_call_expr (fndecl, 2, tem, arg2);
9593
9594   return NULL_TREE;
9595 }
9596
9597 /* Fold a call to builtin isascii with argument ARG.  */
9598
9599 static tree
9600 fold_builtin_isascii (tree arg)
9601 {
9602   if (!validate_arg (arg, INTEGER_TYPE))
9603     return NULL_TREE;
9604   else
9605     {
9606       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
9607       arg = build2 (BIT_AND_EXPR, integer_type_node, arg,
9608                     build_int_cst (NULL_TREE,
9609                                    ~ (unsigned HOST_WIDE_INT) 0x7f));
9610       return fold_build2 (EQ_EXPR, integer_type_node,
9611                           arg, integer_zero_node);
9612     }
9613 }
9614
9615 /* Fold a call to builtin toascii with argument ARG.  */
9616
9617 static tree
9618 fold_builtin_toascii (tree arg)
9619 {
9620   if (!validate_arg (arg, INTEGER_TYPE))
9621     return NULL_TREE;
9622
9623   /* Transform toascii(c) -> (c & 0x7f).  */
9624   return fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9625                       build_int_cst (NULL_TREE, 0x7f));
9626 }
9627
9628 /* Fold a call to builtin isdigit with argument ARG.  */
9629
9630 static tree
9631 fold_builtin_isdigit (tree arg)
9632 {
9633   if (!validate_arg (arg, INTEGER_TYPE))
9634     return NULL_TREE;
9635   else
9636     {
9637       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
9638       /* According to the C standard, isdigit is unaffected by locale.
9639          However, it definitely is affected by the target character set.  */
9640       unsigned HOST_WIDE_INT target_digit0
9641         = lang_hooks.to_target_charset ('0');
9642
9643       if (target_digit0 == 0)
9644         return NULL_TREE;
9645
9646       arg = fold_convert (unsigned_type_node, arg);
9647       arg = build2 (MINUS_EXPR, unsigned_type_node, arg,
9648                     build_int_cst (unsigned_type_node, target_digit0));
9649       return fold_build2 (LE_EXPR, integer_type_node, arg,
9650                           build_int_cst (unsigned_type_node, 9));
9651     }
9652 }
9653
9654 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
9655
9656 static tree
9657 fold_builtin_fabs (tree arg, tree type)
9658 {
9659   if (!validate_arg (arg, REAL_TYPE))
9660     return NULL_TREE;
9661
9662   arg = fold_convert (type, arg);
9663   if (TREE_CODE (arg) == REAL_CST)
9664     return fold_abs_const (arg, type);
9665   return fold_build1 (ABS_EXPR, type, arg);
9666 }
9667
9668 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
9669
9670 static tree
9671 fold_builtin_abs (tree arg, tree type)
9672 {
9673   if (!validate_arg (arg, INTEGER_TYPE))
9674     return NULL_TREE;
9675
9676   arg = fold_convert (type, arg);
9677   if (TREE_CODE (arg) == INTEGER_CST)
9678     return fold_abs_const (arg, type);
9679   return fold_build1 (ABS_EXPR, type, arg);
9680 }
9681
9682 /* Fold a call to builtin fmin or fmax.  */
9683
9684 static tree
9685 fold_builtin_fmin_fmax (tree arg0, tree arg1, tree type, bool max)
9686 {
9687   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9688     {
9689       /* Calculate the result when the argument is a constant.  */
9690       tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9691
9692       if (res)
9693         return res;
9694
9695       /* If either argument is NaN, return the other one.  Avoid the
9696          transformation if we get (and honor) a signalling NaN.  Using
9697          omit_one_operand() ensures we create a non-lvalue.  */
9698       if (TREE_CODE (arg0) == REAL_CST
9699           && real_isnan (&TREE_REAL_CST (arg0))
9700           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9701               || ! TREE_REAL_CST (arg0).signalling))
9702         return omit_one_operand (type, arg1, arg0);
9703       if (TREE_CODE (arg1) == REAL_CST
9704           && real_isnan (&TREE_REAL_CST (arg1))
9705           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9706               || ! TREE_REAL_CST (arg1).signalling))
9707         return omit_one_operand (type, arg0, arg1);
9708
9709       /* Transform fmin/fmax(x,x) -> x.  */
9710       if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9711         return omit_one_operand (type, arg0, arg1);
9712
9713       /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR.  C99 requires these
9714          functions to return the numeric arg if the other one is NaN.
9715          These tree codes don't honor that, so only transform if
9716          -ffinite-math-only is set.  C99 doesn't require -0.0 to be
9717          handled, so we don't have to worry about it either.  */
9718       if (flag_finite_math_only)
9719         return fold_build2 ((max ? MAX_EXPR : MIN_EXPR), type,
9720                             fold_convert (type, arg0),
9721                             fold_convert (type, arg1));
9722     }
9723   return NULL_TREE;
9724 }
9725
9726 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
9727
9728 static tree
9729 fold_builtin_carg (tree arg, tree type)
9730 {
9731   if (validate_arg (arg, COMPLEX_TYPE)
9732       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9733     {
9734       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9735
9736       if (atan2_fn)
9737         {
9738           tree new_arg = builtin_save_expr (arg);
9739           tree r_arg = fold_build1 (REALPART_EXPR, type, new_arg);
9740           tree i_arg = fold_build1 (IMAGPART_EXPR, type, new_arg);
9741           return build_call_expr (atan2_fn, 2, i_arg, r_arg);
9742         }
9743     }
9744
9745   return NULL_TREE;
9746 }
9747
9748 /* Fold a call to builtin logb/ilogb.  */
9749
9750 static tree
9751 fold_builtin_logb (tree arg, tree rettype)
9752 {
9753   if (! validate_arg (arg, REAL_TYPE))
9754     return NULL_TREE;
9755
9756   STRIP_NOPS (arg);
9757
9758   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9759     {
9760       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9761
9762       switch (value->cl)
9763       {
9764       case rvc_nan:
9765       case rvc_inf:
9766         /* If arg is Inf or NaN and we're logb, return it.  */
9767         if (TREE_CODE (rettype) == REAL_TYPE)
9768           return fold_convert (rettype, arg);
9769         /* Fall through... */
9770       case rvc_zero:
9771         /* Zero may set errno and/or raise an exception for logb, also
9772            for ilogb we don't know FP_ILOGB0.  */
9773         return NULL_TREE;
9774       case rvc_normal:
9775         /* For normal numbers, proceed iff radix == 2.  In GCC,
9776            normalized significands are in the range [0.5, 1.0).  We
9777            want the exponent as if they were [1.0, 2.0) so get the
9778            exponent and subtract 1.  */
9779         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9780           return fold_convert (rettype, build_int_cst (NULL_TREE,
9781                                                        REAL_EXP (value)-1));
9782         break;
9783       }
9784     }
9785
9786   return NULL_TREE;
9787 }
9788
9789 /* Fold a call to builtin significand, if radix == 2.  */
9790
9791 static tree
9792 fold_builtin_significand (tree arg, tree rettype)
9793 {
9794   if (! validate_arg (arg, REAL_TYPE))
9795     return NULL_TREE;
9796
9797   STRIP_NOPS (arg);
9798
9799   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9800     {
9801       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9802
9803       switch (value->cl)
9804       {
9805       case rvc_zero:
9806       case rvc_nan:
9807       case rvc_inf:
9808         /* If arg is +-0, +-Inf or +-NaN, then return it.  */
9809         return fold_convert (rettype, arg);
9810       case rvc_normal:
9811         /* For normal numbers, proceed iff radix == 2.  */
9812         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9813           {
9814             REAL_VALUE_TYPE result = *value;
9815             /* In GCC, normalized significands are in the range [0.5,
9816                1.0).  We want them to be [1.0, 2.0) so set the
9817                exponent to 1.  */
9818             SET_REAL_EXP (&result, 1);
9819             return build_real (rettype, result);
9820           }
9821         break;
9822       }
9823     }
9824
9825   return NULL_TREE;
9826 }
9827
9828 /* Fold a call to builtin frexp, we can assume the base is 2.  */
9829
9830 static tree
9831 fold_builtin_frexp (tree arg0, tree arg1, tree rettype)
9832 {
9833   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9834     return NULL_TREE;
9835
9836   STRIP_NOPS (arg0);
9837
9838   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9839     return NULL_TREE;
9840
9841   arg1 = build_fold_indirect_ref (arg1);
9842
9843   /* Proceed if a valid pointer type was passed in.  */
9844   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9845     {
9846       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9847       tree frac, exp;
9848
9849       switch (value->cl)
9850       {
9851       case rvc_zero:
9852         /* For +-0, return (*exp = 0, +-0).  */
9853         exp = integer_zero_node;
9854         frac = arg0;
9855         break;
9856       case rvc_nan:
9857       case rvc_inf:
9858         /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
9859         return omit_one_operand (rettype, arg0, arg1);
9860       case rvc_normal:
9861         {
9862           /* Since the frexp function always expects base 2, and in
9863              GCC normalized significands are already in the range
9864              [0.5, 1.0), we have exactly what frexp wants.  */
9865           REAL_VALUE_TYPE frac_rvt = *value;
9866           SET_REAL_EXP (&frac_rvt, 0);
9867           frac = build_real (rettype, frac_rvt);
9868           exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9869         }
9870         break;
9871       default:
9872         gcc_unreachable ();
9873       }
9874
9875       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9876       arg1 = fold_build2 (MODIFY_EXPR, rettype, arg1, exp);
9877       TREE_SIDE_EFFECTS (arg1) = 1;
9878       return fold_build2 (COMPOUND_EXPR, rettype, arg1, frac);
9879     }
9880
9881   return NULL_TREE;
9882 }
9883
9884 /* Fold a call to builtin ldexp or scalbn/scalbln.  If LDEXP is true
9885    then we can assume the base is two.  If it's false, then we have to
9886    check the mode of the TYPE parameter in certain cases.  */
9887
9888 static tree
9889 fold_builtin_load_exponent (tree arg0, tree arg1, tree type, bool ldexp)
9890 {
9891   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9892     {
9893       STRIP_NOPS (arg0);
9894       STRIP_NOPS (arg1);
9895
9896       /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0.  */
9897       if (real_zerop (arg0) || integer_zerop (arg1)
9898           || (TREE_CODE (arg0) == REAL_CST
9899               && !real_isfinite (&TREE_REAL_CST (arg0))))
9900         return omit_one_operand (type, arg0, arg1);
9901
9902       /* If both arguments are constant, then try to evaluate it.  */
9903       if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9904           && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9905           && host_integerp (arg1, 0))
9906         {
9907           /* Bound the maximum adjustment to twice the range of the
9908              mode's valid exponents.  Use abs to ensure the range is
9909              positive as a sanity check.  */
9910           const long max_exp_adj = 2 *
9911             labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9912                  - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9913
9914           /* Get the user-requested adjustment.  */
9915           const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9916
9917           /* The requested adjustment must be inside this range.  This
9918              is a preliminary cap to avoid things like overflow, we
9919              may still fail to compute the result for other reasons.  */
9920           if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9921             {
9922               REAL_VALUE_TYPE initial_result;
9923
9924               real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9925
9926               /* Ensure we didn't overflow.  */
9927               if (! real_isinf (&initial_result))
9928                 {
9929                   const REAL_VALUE_TYPE trunc_result
9930                     = real_value_truncate (TYPE_MODE (type), initial_result);
9931
9932                   /* Only proceed if the target mode can hold the
9933                      resulting value.  */
9934                   if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9935                     return build_real (type, trunc_result);
9936                 }
9937             }
9938         }
9939     }
9940
9941   return NULL_TREE;
9942 }
9943
9944 /* Fold a call to builtin modf.  */
9945
9946 static tree
9947 fold_builtin_modf (tree arg0, tree arg1, tree rettype)
9948 {
9949   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9950     return NULL_TREE;
9951
9952   STRIP_NOPS (arg0);
9953
9954   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9955     return NULL_TREE;
9956
9957   arg1 = build_fold_indirect_ref (arg1);
9958
9959   /* Proceed if a valid pointer type was passed in.  */
9960   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9961     {
9962       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9963       REAL_VALUE_TYPE trunc, frac;
9964
9965       switch (value->cl)
9966       {
9967       case rvc_nan:
9968       case rvc_zero:
9969         /* For +-NaN or +-0, return (*arg1 = arg0, arg0).  */
9970         trunc = frac = *value;
9971         break;
9972       case rvc_inf:
9973         /* For +-Inf, return (*arg1 = arg0, +-0).  */
9974         frac = dconst0;
9975         frac.sign = value->sign;
9976         trunc = *value;
9977         break;
9978       case rvc_normal:
9979         /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)).  */
9980         real_trunc (&trunc, VOIDmode, value);
9981         real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9982         /* If the original number was negative and already
9983            integral, then the fractional part is -0.0.  */
9984         if (value->sign && frac.cl == rvc_zero)
9985           frac.sign = value->sign;
9986         break;
9987       }
9988
9989       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9990       arg1 = fold_build2 (MODIFY_EXPR, rettype, arg1,
9991                           build_real (rettype, trunc));
9992       TREE_SIDE_EFFECTS (arg1) = 1;
9993       return fold_build2 (COMPOUND_EXPR, rettype, arg1,
9994                           build_real (rettype, frac));
9995     }
9996
9997   return NULL_TREE;
9998 }
9999
10000 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
10001    ARG is the argument for the call.  */
10002
10003 static tree
10004 fold_builtin_classify (tree fndecl, tree arg, int builtin_index)
10005 {
10006   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10007   REAL_VALUE_TYPE r;
10008
10009   if (!validate_arg (arg, REAL_TYPE))
10010     return NULL_TREE;
10011
10012   switch (builtin_index)
10013     {
10014     case BUILT_IN_ISINF:
10015       if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
10016         return omit_one_operand (type, integer_zero_node, arg);
10017
10018       if (TREE_CODE (arg) == REAL_CST)
10019         {
10020           r = TREE_REAL_CST (arg);
10021           if (real_isinf (&r))
10022             return real_compare (GT_EXPR, &r, &dconst0)
10023                    ? integer_one_node : integer_minus_one_node;
10024           else
10025             return integer_zero_node;
10026         }
10027
10028       return NULL_TREE;
10029
10030     case BUILT_IN_ISINF_SIGN:
10031       {
10032         /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
10033         /* In a boolean context, GCC will fold the inner COND_EXPR to
10034            1.  So e.g. "if (isinf_sign(x))" would be folded to just
10035            "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
10036         tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
10037         tree isinf_fn = built_in_decls[BUILT_IN_ISINF];
10038         tree tmp = NULL_TREE;
10039
10040         arg = builtin_save_expr (arg);
10041
10042         if (signbit_fn && isinf_fn)
10043           {
10044             tree signbit_call = build_call_expr (signbit_fn, 1, arg);
10045             tree isinf_call = build_call_expr (isinf_fn, 1, arg);
10046
10047             signbit_call = fold_build2 (NE_EXPR, integer_type_node,
10048                                         signbit_call, integer_zero_node);
10049             isinf_call = fold_build2 (NE_EXPR, integer_type_node,
10050                                       isinf_call, integer_zero_node);
10051
10052             tmp = fold_build3 (COND_EXPR, integer_type_node, signbit_call,
10053                                integer_minus_one_node, integer_one_node);
10054             tmp = fold_build3 (COND_EXPR, integer_type_node, isinf_call, tmp,
10055                                integer_zero_node);
10056           }
10057
10058         return tmp;
10059       }
10060
10061     case BUILT_IN_ISFINITE:
10062       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
10063           && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
10064         return omit_one_operand (type, integer_one_node, arg);
10065
10066       if (TREE_CODE (arg) == REAL_CST)
10067         {
10068           r = TREE_REAL_CST (arg);
10069           return real_isfinite (&r) ? integer_one_node : integer_zero_node;
10070         }
10071
10072       return NULL_TREE;
10073
10074     case BUILT_IN_ISNAN:
10075       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
10076         return omit_one_operand (type, integer_zero_node, arg);
10077
10078       if (TREE_CODE (arg) == REAL_CST)
10079         {
10080           r = TREE_REAL_CST (arg);
10081           return real_isnan (&r) ? integer_one_node : integer_zero_node;
10082         }
10083
10084       arg = builtin_save_expr (arg);
10085       return fold_build2 (UNORDERED_EXPR, type, arg, arg);
10086
10087     default:
10088       gcc_unreachable ();
10089     }
10090 }
10091
10092 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
10093    This builtin will generate code to return the appropriate floating
10094    point classification depending on the value of the floating point
10095    number passed in.  The possible return values must be supplied as
10096    int arguments to the call in the following order: FP_NAN, FP_INFINITE,
10097    FP_NORMAL, FP_SUBNORMAL and FP_ZERO.  The ellipses is for exactly
10098    one floating point argument which is "type generic".  */
10099
10100 static tree
10101 fold_builtin_fpclassify (tree exp)
10102 {
10103   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
10104     arg, type, res, tmp;
10105   enum machine_mode mode;
10106   REAL_VALUE_TYPE r;
10107   char buf[128];
10108
10109   /* Verify the required arguments in the original call.  */
10110   if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
10111                          INTEGER_TYPE, INTEGER_TYPE,
10112                          INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
10113     return NULL_TREE;
10114
10115   fp_nan = CALL_EXPR_ARG (exp, 0);
10116   fp_infinite = CALL_EXPR_ARG (exp, 1);
10117   fp_normal = CALL_EXPR_ARG (exp, 2);
10118   fp_subnormal = CALL_EXPR_ARG (exp, 3);
10119   fp_zero = CALL_EXPR_ARG (exp, 4);
10120   arg = CALL_EXPR_ARG (exp, 5);
10121   type = TREE_TYPE (arg);
10122   mode = TYPE_MODE (type);
10123   arg = builtin_save_expr (fold_build1 (ABS_EXPR, type, arg));
10124
10125   /* fpclassify(x) ->
10126        isnan(x) ? FP_NAN :
10127          (fabs(x) == Inf ? FP_INFINITE :
10128            (fabs(x) >= DBL_MIN ? FP_NORMAL :
10129              (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
10130
10131   tmp = fold_build2 (EQ_EXPR, integer_type_node, arg,
10132                      build_real (type, dconst0));
10133   res = fold_build3 (COND_EXPR, integer_type_node, tmp, fp_zero, fp_subnormal);
10134
10135   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
10136   real_from_string (&r, buf);
10137   tmp = fold_build2 (GE_EXPR, integer_type_node, arg, build_real (type, r));
10138   res = fold_build3 (COND_EXPR, integer_type_node, tmp, fp_normal, res);
10139
10140   if (HONOR_INFINITIES (mode))
10141     {
10142       real_inf (&r);
10143       tmp = fold_build2 (EQ_EXPR, integer_type_node, arg,
10144                          build_real (type, r));
10145       res = fold_build3 (COND_EXPR, integer_type_node, tmp, fp_infinite, res);
10146     }
10147
10148   if (HONOR_NANS (mode))
10149     {
10150       tmp = fold_build2 (ORDERED_EXPR, integer_type_node, arg, arg);
10151       res = fold_build3 (COND_EXPR, integer_type_node, tmp, res, fp_nan);
10152     }
10153
10154   return res;
10155 }
10156
10157 /* Fold a call to an unordered comparison function such as
10158    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
10159    being called and ARG0 and ARG1 are the arguments for the call.
10160    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
10161    the opposite of the desired result.  UNORDERED_CODE is used
10162    for modes that can hold NaNs and ORDERED_CODE is used for
10163    the rest.  */
10164
10165 static tree
10166 fold_builtin_unordered_cmp (tree fndecl, tree arg0, tree arg1,
10167                             enum tree_code unordered_code,
10168                             enum tree_code ordered_code)
10169 {
10170   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10171   enum tree_code code;
10172   tree type0, type1;
10173   enum tree_code code0, code1;
10174   tree cmp_type = NULL_TREE;
10175
10176   type0 = TREE_TYPE (arg0);
10177   type1 = TREE_TYPE (arg1);
10178
10179   code0 = TREE_CODE (type0);
10180   code1 = TREE_CODE (type1);
10181
10182   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
10183     /* Choose the wider of two real types.  */
10184     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
10185       ? type0 : type1;
10186   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
10187     cmp_type = type0;
10188   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
10189     cmp_type = type1;
10190
10191   arg0 = fold_convert (cmp_type, arg0);
10192   arg1 = fold_convert (cmp_type, arg1);
10193
10194   if (unordered_code == UNORDERED_EXPR)
10195     {
10196       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
10197         return omit_two_operands (type, integer_zero_node, arg0, arg1);
10198       return fold_build2 (UNORDERED_EXPR, type, arg0, arg1);
10199     }
10200
10201   code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
10202                                                    : ordered_code;
10203   return fold_build1 (TRUTH_NOT_EXPR, type,
10204                       fold_build2 (code, type, arg0, arg1));
10205 }
10206
10207 /* Fold a call to built-in function FNDECL with 0 arguments.
10208    IGNORE is true if the result of the function call is ignored.  This
10209    function returns NULL_TREE if no simplification was possible.  */
10210
10211 static tree
10212 fold_builtin_0 (tree fndecl, bool ignore ATTRIBUTE_UNUSED)
10213 {
10214   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10215   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10216   switch (fcode)
10217     {
10218     CASE_FLT_FN (BUILT_IN_INF):
10219     case BUILT_IN_INFD32:
10220     case BUILT_IN_INFD64:
10221     case BUILT_IN_INFD128:
10222       return fold_builtin_inf (type, true);
10223
10224     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
10225       return fold_builtin_inf (type, false);
10226
10227     case BUILT_IN_CLASSIFY_TYPE:
10228       return fold_builtin_classify_type (NULL_TREE);
10229
10230     default:
10231       break;
10232     }
10233   return NULL_TREE;
10234 }
10235
10236 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
10237    IGNORE is true if the result of the function call is ignored.  This
10238    function returns NULL_TREE if no simplification was possible.  */
10239
10240 static tree
10241 fold_builtin_1 (tree fndecl, tree arg0, bool ignore)
10242 {
10243   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10244   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10245   switch (fcode)
10246     {
10247
10248     case BUILT_IN_CONSTANT_P:
10249       {
10250         tree val = fold_builtin_constant_p (arg0);
10251
10252         /* Gimplification will pull the CALL_EXPR for the builtin out of
10253            an if condition.  When not optimizing, we'll not CSE it back.
10254            To avoid link error types of regressions, return false now.  */
10255         if (!val && !optimize)
10256           val = integer_zero_node;
10257
10258         return val;
10259       }
10260
10261     case BUILT_IN_CLASSIFY_TYPE:
10262       return fold_builtin_classify_type (arg0);
10263
10264     case BUILT_IN_STRLEN:
10265       return fold_builtin_strlen (arg0);
10266
10267     CASE_FLT_FN (BUILT_IN_FABS):
10268       return fold_builtin_fabs (arg0, type);
10269
10270     case BUILT_IN_ABS:
10271     case BUILT_IN_LABS:
10272     case BUILT_IN_LLABS:
10273     case BUILT_IN_IMAXABS:
10274       return fold_builtin_abs (arg0, type);
10275
10276     CASE_FLT_FN (BUILT_IN_CONJ):
10277       if (validate_arg (arg0, COMPLEX_TYPE)
10278         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10279         return fold_build1 (CONJ_EXPR, type, arg0);
10280     break;
10281
10282     CASE_FLT_FN (BUILT_IN_CREAL):
10283       if (validate_arg (arg0, COMPLEX_TYPE)
10284         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10285         return non_lvalue (fold_build1 (REALPART_EXPR, type, arg0));;
10286     break;
10287
10288     CASE_FLT_FN (BUILT_IN_CIMAG):
10289       if (validate_arg (arg0, COMPLEX_TYPE))
10290         return non_lvalue (fold_build1 (IMAGPART_EXPR, type, arg0));
10291     break;
10292
10293     CASE_FLT_FN (BUILT_IN_CCOS):
10294       return fold_builtin_ccos(arg0, type, fndecl, /*hyper=*/ false);
10295
10296     CASE_FLT_FN (BUILT_IN_CCOSH):
10297       return fold_builtin_ccos(arg0, type, fndecl, /*hyper=*/ true);
10298
10299 #ifdef HAVE_mpc
10300     CASE_FLT_FN (BUILT_IN_CSIN):
10301       if (validate_arg (arg0, COMPLEX_TYPE)
10302           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10303         return do_mpc_arg1 (arg0, type, mpc_sin);
10304     break;
10305
10306     CASE_FLT_FN (BUILT_IN_CSINH):
10307       if (validate_arg (arg0, COMPLEX_TYPE)
10308           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10309         return do_mpc_arg1 (arg0, type, mpc_sinh);
10310     break;
10311
10312     CASE_FLT_FN (BUILT_IN_CTAN):
10313       if (validate_arg (arg0, COMPLEX_TYPE)
10314           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10315         return do_mpc_arg1 (arg0, type, mpc_tan);
10316     break;
10317
10318     CASE_FLT_FN (BUILT_IN_CTANH):
10319       if (validate_arg (arg0, COMPLEX_TYPE)
10320           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10321         return do_mpc_arg1 (arg0, type, mpc_tanh);
10322     break;
10323
10324     CASE_FLT_FN (BUILT_IN_CLOG):
10325       if (validate_arg (arg0, COMPLEX_TYPE)
10326           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10327         return do_mpc_arg1 (arg0, type, mpc_log);
10328     break;
10329
10330     CASE_FLT_FN (BUILT_IN_CSQRT):
10331       if (validate_arg (arg0, COMPLEX_TYPE)
10332           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10333         return do_mpc_arg1 (arg0, type, mpc_sqrt);
10334     break;
10335 #endif
10336
10337     CASE_FLT_FN (BUILT_IN_CABS):
10338       return fold_builtin_cabs (arg0, type, fndecl);
10339
10340     CASE_FLT_FN (BUILT_IN_CARG):
10341       return fold_builtin_carg (arg0, type);
10342
10343     CASE_FLT_FN (BUILT_IN_SQRT):
10344       return fold_builtin_sqrt (arg0, type);
10345
10346     CASE_FLT_FN (BUILT_IN_CBRT):
10347       return fold_builtin_cbrt (arg0, type);
10348
10349     CASE_FLT_FN (BUILT_IN_ASIN):
10350       if (validate_arg (arg0, REAL_TYPE))
10351         return do_mpfr_arg1 (arg0, type, mpfr_asin,
10352                              &dconstm1, &dconst1, true);
10353     break;
10354
10355     CASE_FLT_FN (BUILT_IN_ACOS):
10356       if (validate_arg (arg0, REAL_TYPE))
10357         return do_mpfr_arg1 (arg0, type, mpfr_acos,
10358                              &dconstm1, &dconst1, true);
10359     break;
10360
10361     CASE_FLT_FN (BUILT_IN_ATAN):
10362       if (validate_arg (arg0, REAL_TYPE))
10363         return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10364     break;
10365
10366     CASE_FLT_FN (BUILT_IN_ASINH):
10367       if (validate_arg (arg0, REAL_TYPE))
10368         return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10369     break;
10370
10371     CASE_FLT_FN (BUILT_IN_ACOSH):
10372       if (validate_arg (arg0, REAL_TYPE))
10373         return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10374                              &dconst1, NULL, true);
10375     break;
10376
10377     CASE_FLT_FN (BUILT_IN_ATANH):
10378       if (validate_arg (arg0, REAL_TYPE))
10379         return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10380                              &dconstm1, &dconst1, false);
10381     break;
10382
10383     CASE_FLT_FN (BUILT_IN_SIN):
10384       if (validate_arg (arg0, REAL_TYPE))
10385         return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10386     break;
10387
10388     CASE_FLT_FN (BUILT_IN_COS):
10389       return fold_builtin_cos (arg0, type, fndecl);
10390
10391     CASE_FLT_FN (BUILT_IN_TAN):
10392       return fold_builtin_tan (arg0, type);
10393
10394     CASE_FLT_FN (BUILT_IN_CEXP):
10395       return fold_builtin_cexp (arg0, type);
10396
10397     CASE_FLT_FN (BUILT_IN_CEXPI):
10398       if (validate_arg (arg0, REAL_TYPE))
10399         return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10400     break;
10401
10402     CASE_FLT_FN (BUILT_IN_SINH):
10403       if (validate_arg (arg0, REAL_TYPE))
10404         return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10405     break;
10406
10407     CASE_FLT_FN (BUILT_IN_COSH):
10408       return fold_builtin_cosh (arg0, type, fndecl);
10409
10410     CASE_FLT_FN (BUILT_IN_TANH):
10411       if (validate_arg (arg0, REAL_TYPE))
10412         return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10413     break;
10414
10415     CASE_FLT_FN (BUILT_IN_ERF):
10416       if (validate_arg (arg0, REAL_TYPE))
10417         return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10418     break;
10419
10420     CASE_FLT_FN (BUILT_IN_ERFC):
10421       if (validate_arg (arg0, REAL_TYPE))
10422         return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10423     break;
10424
10425     CASE_FLT_FN (BUILT_IN_TGAMMA):
10426       if (validate_arg (arg0, REAL_TYPE))
10427         return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10428     break;
10429
10430     CASE_FLT_FN (BUILT_IN_EXP):
10431       return fold_builtin_exponent (fndecl, arg0, mpfr_exp);
10432
10433     CASE_FLT_FN (BUILT_IN_EXP2):
10434       return fold_builtin_exponent (fndecl, arg0, mpfr_exp2);
10435
10436     CASE_FLT_FN (BUILT_IN_EXP10):
10437     CASE_FLT_FN (BUILT_IN_POW10):
10438       return fold_builtin_exponent (fndecl, arg0, mpfr_exp10);
10439
10440     CASE_FLT_FN (BUILT_IN_EXPM1):
10441       if (validate_arg (arg0, REAL_TYPE))
10442         return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10443     break;
10444
10445     CASE_FLT_FN (BUILT_IN_LOG):
10446       return fold_builtin_logarithm (fndecl, arg0, mpfr_log);
10447
10448     CASE_FLT_FN (BUILT_IN_LOG2):
10449       return fold_builtin_logarithm (fndecl, arg0, mpfr_log2);
10450
10451     CASE_FLT_FN (BUILT_IN_LOG10):
10452       return fold_builtin_logarithm (fndecl, arg0, mpfr_log10);
10453
10454     CASE_FLT_FN (BUILT_IN_LOG1P):
10455       if (validate_arg (arg0, REAL_TYPE))
10456         return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10457                              &dconstm1, NULL, false);
10458     break;
10459
10460     CASE_FLT_FN (BUILT_IN_J0):
10461       if (validate_arg (arg0, REAL_TYPE))
10462         return do_mpfr_arg1 (arg0, type, mpfr_j0,
10463                              NULL, NULL, 0);
10464     break;
10465
10466     CASE_FLT_FN (BUILT_IN_J1):
10467       if (validate_arg (arg0, REAL_TYPE))
10468         return do_mpfr_arg1 (arg0, type, mpfr_j1,
10469                              NULL, NULL, 0);
10470     break;
10471
10472     CASE_FLT_FN (BUILT_IN_Y0):
10473       if (validate_arg (arg0, REAL_TYPE))
10474         return do_mpfr_arg1 (arg0, type, mpfr_y0,
10475                              &dconst0, NULL, false);
10476     break;
10477
10478     CASE_FLT_FN (BUILT_IN_Y1):
10479       if (validate_arg (arg0, REAL_TYPE))
10480         return do_mpfr_arg1 (arg0, type, mpfr_y1,
10481                              &dconst0, NULL, false);
10482     break;
10483
10484     CASE_FLT_FN (BUILT_IN_NAN):
10485     case BUILT_IN_NAND32:
10486     case BUILT_IN_NAND64:
10487     case BUILT_IN_NAND128:
10488       return fold_builtin_nan (arg0, type, true);
10489
10490     CASE_FLT_FN (BUILT_IN_NANS):
10491       return fold_builtin_nan (arg0, type, false);
10492
10493     CASE_FLT_FN (BUILT_IN_FLOOR):
10494       return fold_builtin_floor (fndecl, arg0);
10495
10496     CASE_FLT_FN (BUILT_IN_CEIL):
10497       return fold_builtin_ceil (fndecl, arg0);
10498
10499     CASE_FLT_FN (BUILT_IN_TRUNC):
10500       return fold_builtin_trunc (fndecl, arg0);
10501
10502     CASE_FLT_FN (BUILT_IN_ROUND):
10503       return fold_builtin_round (fndecl, arg0);
10504
10505     CASE_FLT_FN (BUILT_IN_NEARBYINT):
10506     CASE_FLT_FN (BUILT_IN_RINT):
10507       return fold_trunc_transparent_mathfn (fndecl, arg0);
10508
10509     CASE_FLT_FN (BUILT_IN_LCEIL):
10510     CASE_FLT_FN (BUILT_IN_LLCEIL):
10511     CASE_FLT_FN (BUILT_IN_LFLOOR):
10512     CASE_FLT_FN (BUILT_IN_LLFLOOR):
10513     CASE_FLT_FN (BUILT_IN_LROUND):
10514     CASE_FLT_FN (BUILT_IN_LLROUND):
10515       return fold_builtin_int_roundingfn (fndecl, arg0);
10516
10517     CASE_FLT_FN (BUILT_IN_LRINT):
10518     CASE_FLT_FN (BUILT_IN_LLRINT):
10519       return fold_fixed_mathfn (fndecl, arg0);
10520
10521     case BUILT_IN_BSWAP32:
10522     case BUILT_IN_BSWAP64:
10523       return fold_builtin_bswap (fndecl, arg0);
10524
10525     CASE_INT_FN (BUILT_IN_FFS):
10526     CASE_INT_FN (BUILT_IN_CLZ):
10527     CASE_INT_FN (BUILT_IN_CTZ):
10528     CASE_INT_FN (BUILT_IN_POPCOUNT):
10529     CASE_INT_FN (BUILT_IN_PARITY):
10530       return fold_builtin_bitop (fndecl, arg0);
10531
10532     CASE_FLT_FN (BUILT_IN_SIGNBIT):
10533       return fold_builtin_signbit (arg0, type);
10534
10535     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10536       return fold_builtin_significand (arg0, type);
10537
10538     CASE_FLT_FN (BUILT_IN_ILOGB):
10539     CASE_FLT_FN (BUILT_IN_LOGB):
10540       return fold_builtin_logb (arg0, type);
10541
10542     case BUILT_IN_ISASCII:
10543       return fold_builtin_isascii (arg0);
10544
10545     case BUILT_IN_TOASCII:
10546       return fold_builtin_toascii (arg0);
10547
10548     case BUILT_IN_ISDIGIT:
10549       return fold_builtin_isdigit (arg0);
10550
10551     CASE_FLT_FN (BUILT_IN_FINITE):
10552     case BUILT_IN_FINITED32:
10553     case BUILT_IN_FINITED64:
10554     case BUILT_IN_FINITED128:
10555     case BUILT_IN_ISFINITE:
10556       return fold_builtin_classify (fndecl, arg0, BUILT_IN_ISFINITE);
10557
10558     CASE_FLT_FN (BUILT_IN_ISINF):
10559     case BUILT_IN_ISINFD32:
10560     case BUILT_IN_ISINFD64:
10561     case BUILT_IN_ISINFD128:
10562       return fold_builtin_classify (fndecl, arg0, BUILT_IN_ISINF);
10563
10564     case BUILT_IN_ISINF_SIGN:
10565       return fold_builtin_classify (fndecl, arg0, BUILT_IN_ISINF_SIGN);
10566
10567     CASE_FLT_FN (BUILT_IN_ISNAN):
10568     case BUILT_IN_ISNAND32:
10569     case BUILT_IN_ISNAND64:
10570     case BUILT_IN_ISNAND128:
10571       return fold_builtin_classify (fndecl, arg0, BUILT_IN_ISNAN);
10572
10573     case BUILT_IN_PRINTF:
10574     case BUILT_IN_PRINTF_UNLOCKED:
10575     case BUILT_IN_VPRINTF:
10576       return fold_builtin_printf (fndecl, arg0, NULL_TREE, ignore, fcode);
10577
10578     default:
10579       break;
10580     }
10581
10582   return NULL_TREE;
10583
10584 }
10585
10586 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10587    IGNORE is true if the result of the function call is ignored.  This
10588    function returns NULL_TREE if no simplification was possible.  */
10589
10590 static tree
10591 fold_builtin_2 (tree fndecl, tree arg0, tree arg1, bool ignore)
10592 {
10593   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10594   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10595
10596   switch (fcode)
10597     {
10598     CASE_FLT_FN (BUILT_IN_JN):
10599       if (validate_arg (arg0, INTEGER_TYPE)
10600           && validate_arg (arg1, REAL_TYPE))
10601         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10602     break;
10603
10604     CASE_FLT_FN (BUILT_IN_YN):
10605       if (validate_arg (arg0, INTEGER_TYPE)
10606           && validate_arg (arg1, REAL_TYPE))
10607         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10608                                  &dconst0, false);
10609     break;
10610
10611     CASE_FLT_FN (BUILT_IN_DREM):
10612     CASE_FLT_FN (BUILT_IN_REMAINDER):
10613       if (validate_arg (arg0, REAL_TYPE)
10614           && validate_arg(arg1, REAL_TYPE))
10615         return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10616     break;
10617
10618     CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10619     CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10620       if (validate_arg (arg0, REAL_TYPE)
10621           && validate_arg(arg1, POINTER_TYPE))
10622         return do_mpfr_lgamma_r (arg0, arg1, type);
10623     break;
10624
10625     CASE_FLT_FN (BUILT_IN_ATAN2):
10626       if (validate_arg (arg0, REAL_TYPE)
10627           && validate_arg(arg1, REAL_TYPE))
10628         return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10629     break;
10630
10631     CASE_FLT_FN (BUILT_IN_FDIM):
10632       if (validate_arg (arg0, REAL_TYPE)
10633           && validate_arg(arg1, REAL_TYPE))
10634         return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10635     break;
10636
10637     CASE_FLT_FN (BUILT_IN_HYPOT):
10638       return fold_builtin_hypot (fndecl, arg0, arg1, type);
10639
10640     CASE_FLT_FN (BUILT_IN_LDEXP):
10641       return fold_builtin_load_exponent (arg0, arg1, type, /*ldexp=*/true);
10642     CASE_FLT_FN (BUILT_IN_SCALBN):
10643     CASE_FLT_FN (BUILT_IN_SCALBLN):
10644       return fold_builtin_load_exponent (arg0, arg1, type, /*ldexp=*/false);
10645
10646     CASE_FLT_FN (BUILT_IN_FREXP):
10647       return fold_builtin_frexp (arg0, arg1, type);
10648
10649     CASE_FLT_FN (BUILT_IN_MODF):
10650       return fold_builtin_modf (arg0, arg1, type);
10651
10652     case BUILT_IN_BZERO:
10653       return fold_builtin_bzero (arg0, arg1, ignore);
10654
10655     case BUILT_IN_FPUTS:
10656       return fold_builtin_fputs (arg0, arg1, ignore, false, NULL_TREE);
10657
10658     case BUILT_IN_FPUTS_UNLOCKED:
10659       return fold_builtin_fputs (arg0, arg1, ignore, true, NULL_TREE);
10660
10661     case BUILT_IN_STRSTR:
10662       return fold_builtin_strstr (arg0, arg1, type);
10663
10664     case BUILT_IN_STRCAT:
10665       return fold_builtin_strcat (arg0, arg1);
10666
10667     case BUILT_IN_STRSPN:
10668       return fold_builtin_strspn (arg0, arg1);
10669
10670     case BUILT_IN_STRCSPN:
10671       return fold_builtin_strcspn (arg0, arg1);
10672
10673     case BUILT_IN_STRCHR:
10674     case BUILT_IN_INDEX:
10675       return fold_builtin_strchr (arg0, arg1, type);
10676
10677     case BUILT_IN_STRRCHR:
10678     case BUILT_IN_RINDEX:
10679       return fold_builtin_strrchr (arg0, arg1, type);
10680
10681     case BUILT_IN_STRCPY:
10682       return fold_builtin_strcpy (fndecl, arg0, arg1, NULL_TREE);
10683
10684     case BUILT_IN_STPCPY:
10685       if (ignore)
10686         {
10687           tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
10688           if (!fn)
10689             break;
10690
10691           return build_call_expr (fn, 2, arg0, arg1);
10692         }
10693       break;
10694
10695     case BUILT_IN_STRCMP:
10696       return fold_builtin_strcmp (arg0, arg1);
10697
10698     case BUILT_IN_STRPBRK:
10699       return fold_builtin_strpbrk (arg0, arg1, type);
10700
10701     case BUILT_IN_EXPECT:
10702       return fold_builtin_expect (arg0, arg1);
10703
10704     CASE_FLT_FN (BUILT_IN_POW):
10705       return fold_builtin_pow (fndecl, arg0, arg1, type);
10706
10707     CASE_FLT_FN (BUILT_IN_POWI):
10708       return fold_builtin_powi (fndecl, arg0, arg1, type);
10709
10710     CASE_FLT_FN (BUILT_IN_COPYSIGN):
10711       return fold_builtin_copysign (fndecl, arg0, arg1, type);
10712
10713     CASE_FLT_FN (BUILT_IN_FMIN):
10714       return fold_builtin_fmin_fmax (arg0, arg1, type, /*max=*/false);
10715
10716     CASE_FLT_FN (BUILT_IN_FMAX):
10717       return fold_builtin_fmin_fmax (arg0, arg1, type, /*max=*/true);
10718
10719     case BUILT_IN_ISGREATER:
10720       return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNLE_EXPR, LE_EXPR);
10721     case BUILT_IN_ISGREATEREQUAL:
10722       return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNLT_EXPR, LT_EXPR);
10723     case BUILT_IN_ISLESS:
10724       return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNGE_EXPR, GE_EXPR);
10725     case BUILT_IN_ISLESSEQUAL:
10726       return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNGT_EXPR, GT_EXPR);
10727     case BUILT_IN_ISLESSGREATER:
10728       return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10729     case BUILT_IN_ISUNORDERED:
10730       return fold_builtin_unordered_cmp (fndecl, arg0, arg1, UNORDERED_EXPR,
10731                                          NOP_EXPR);
10732
10733       /* We do the folding for va_start in the expander.  */
10734     case BUILT_IN_VA_START:
10735       break;
10736
10737     case BUILT_IN_SPRINTF:
10738       return fold_builtin_sprintf (arg0, arg1, NULL_TREE, ignore);
10739
10740     case BUILT_IN_OBJECT_SIZE:
10741       return fold_builtin_object_size (arg0, arg1);
10742
10743     case BUILT_IN_PRINTF:
10744     case BUILT_IN_PRINTF_UNLOCKED:
10745     case BUILT_IN_VPRINTF:
10746       return fold_builtin_printf (fndecl, arg0, arg1, ignore, fcode);
10747
10748     case BUILT_IN_PRINTF_CHK:
10749     case BUILT_IN_VPRINTF_CHK:
10750       if (!validate_arg (arg0, INTEGER_TYPE)
10751           || TREE_SIDE_EFFECTS (arg0))
10752         return NULL_TREE;
10753       else
10754         return fold_builtin_printf (fndecl, arg1, NULL_TREE, ignore, fcode);
10755     break;
10756
10757     case BUILT_IN_FPRINTF:
10758     case BUILT_IN_FPRINTF_UNLOCKED:
10759     case BUILT_IN_VFPRINTF:
10760       return fold_builtin_fprintf (fndecl, arg0, arg1, NULL_TREE,
10761                                    ignore, fcode);
10762
10763     default:
10764       break;
10765     }
10766   return NULL_TREE;
10767 }
10768
10769 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10770    and ARG2.  IGNORE is true if the result of the function call is ignored.
10771    This function returns NULL_TREE if no simplification was possible.  */
10772
10773 static tree
10774 fold_builtin_3 (tree fndecl, tree arg0, tree arg1, tree arg2, bool ignore)
10775 {
10776   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10777   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10778   switch (fcode)
10779     {
10780
10781     CASE_FLT_FN (BUILT_IN_SINCOS):
10782       return fold_builtin_sincos (arg0, arg1, arg2);
10783
10784     CASE_FLT_FN (BUILT_IN_FMA):
10785       if (validate_arg (arg0, REAL_TYPE)
10786           && validate_arg(arg1, REAL_TYPE)
10787           && validate_arg(arg2, REAL_TYPE))
10788         return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
10789     break;
10790
10791     CASE_FLT_FN (BUILT_IN_REMQUO):
10792       if (validate_arg (arg0, REAL_TYPE)
10793           && validate_arg(arg1, REAL_TYPE)
10794           && validate_arg(arg2, POINTER_TYPE))
10795         return do_mpfr_remquo (arg0, arg1, arg2);
10796     break;
10797
10798     case BUILT_IN_MEMSET:
10799       return fold_builtin_memset (arg0, arg1, arg2, type, ignore);
10800
10801     case BUILT_IN_BCOPY:
10802         return fold_builtin_memory_op (arg1, arg0, arg2, void_type_node, true, /*endp=*/3);
10803
10804     case BUILT_IN_MEMCPY:
10805       return fold_builtin_memory_op (arg0, arg1, arg2, type, ignore, /*endp=*/0);
10806
10807     case BUILT_IN_MEMPCPY:
10808       return fold_builtin_memory_op (arg0, arg1, arg2, type, ignore, /*endp=*/1);
10809
10810     case BUILT_IN_MEMMOVE:
10811       return fold_builtin_memory_op (arg0, arg1, arg2, type, ignore, /*endp=*/3);
10812
10813     case BUILT_IN_STRNCAT:
10814       return fold_builtin_strncat (arg0, arg1, arg2);
10815
10816     case BUILT_IN_STRNCPY:
10817       return fold_builtin_strncpy (fndecl, arg0, arg1, arg2, NULL_TREE);
10818
10819     case BUILT_IN_STRNCMP:
10820       return fold_builtin_strncmp (arg0, arg1, arg2);
10821
10822     case BUILT_IN_MEMCHR:
10823       return fold_builtin_memchr (arg0, arg1, arg2, type);
10824
10825     case BUILT_IN_BCMP:
10826     case BUILT_IN_MEMCMP:
10827       return fold_builtin_memcmp (arg0, arg1, arg2);;
10828
10829     case BUILT_IN_SPRINTF:
10830       return fold_builtin_sprintf (arg0, arg1, arg2, ignore);
10831
10832     case BUILT_IN_STRCPY_CHK:
10833     case BUILT_IN_STPCPY_CHK:
10834       return fold_builtin_stxcpy_chk (fndecl, arg0, arg1, arg2, NULL_TREE,
10835                                       ignore, fcode);
10836
10837     case BUILT_IN_STRCAT_CHK:
10838       return fold_builtin_strcat_chk (fndecl, arg0, arg1, arg2);
10839
10840     case BUILT_IN_PRINTF_CHK:
10841     case BUILT_IN_VPRINTF_CHK:
10842       if (!validate_arg (arg0, INTEGER_TYPE)
10843           || TREE_SIDE_EFFECTS (arg0))
10844         return NULL_TREE;
10845       else
10846         return fold_builtin_printf (fndecl, arg1, arg2, ignore, fcode);
10847     break;
10848
10849     case BUILT_IN_FPRINTF:
10850     case BUILT_IN_FPRINTF_UNLOCKED:
10851     case BUILT_IN_VFPRINTF:
10852       return fold_builtin_fprintf (fndecl, arg0, arg1, arg2, ignore, fcode);
10853
10854     case BUILT_IN_FPRINTF_CHK:
10855     case BUILT_IN_VFPRINTF_CHK:
10856       if (!validate_arg (arg1, INTEGER_TYPE)
10857           || TREE_SIDE_EFFECTS (arg1))
10858         return NULL_TREE;
10859       else
10860         return fold_builtin_fprintf (fndecl, arg0, arg2, NULL_TREE,
10861                                      ignore, fcode);
10862
10863     default:
10864       break;
10865     }
10866   return NULL_TREE;
10867 }
10868
10869 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10870    ARG2, and ARG3.  IGNORE is true if the result of the function call is
10871    ignored.  This function returns NULL_TREE if no simplification was
10872    possible.  */
10873
10874 static tree
10875 fold_builtin_4 (tree fndecl, tree arg0, tree arg1, tree arg2, tree arg3,
10876                 bool ignore)
10877 {
10878   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10879
10880   switch (fcode)
10881     {
10882     case BUILT_IN_MEMCPY_CHK:
10883     case BUILT_IN_MEMPCPY_CHK:
10884     case BUILT_IN_MEMMOVE_CHK:
10885     case BUILT_IN_MEMSET_CHK:
10886       return fold_builtin_memory_chk (fndecl, arg0, arg1, arg2, arg3,
10887                                       NULL_TREE, ignore,
10888                                       DECL_FUNCTION_CODE (fndecl));
10889
10890     case BUILT_IN_STRNCPY_CHK:
10891       return fold_builtin_strncpy_chk (arg0, arg1, arg2, arg3, NULL_TREE);
10892
10893     case BUILT_IN_STRNCAT_CHK:
10894       return fold_builtin_strncat_chk (fndecl, arg0, arg1, arg2, arg3);
10895
10896     case BUILT_IN_FPRINTF_CHK:
10897     case BUILT_IN_VFPRINTF_CHK:
10898       if (!validate_arg (arg1, INTEGER_TYPE)
10899           || TREE_SIDE_EFFECTS (arg1))
10900         return NULL_TREE;
10901       else
10902         return fold_builtin_fprintf (fndecl, arg0, arg2, arg3,
10903                                      ignore, fcode);
10904     break;
10905
10906     default:
10907       break;
10908     }
10909   return NULL_TREE;
10910 }
10911
10912 /* Fold a call to built-in function FNDECL.  ARGS is an array of NARGS
10913     arguments, where NARGS <= 4.  IGNORE is true if the result of the
10914     function call is ignored.  This function returns NULL_TREE if no
10915     simplification was possible.  Note that this only folds builtins with
10916     fixed argument patterns.  Foldings that do varargs-to-varargs
10917     transformations, or that match calls with more than 4 arguments,
10918     need to be handled with fold_builtin_varargs instead.  */
10919
10920 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10921
10922 static tree
10923 fold_builtin_n (tree fndecl, tree *args, int nargs, bool ignore)
10924 {
10925   tree ret = NULL_TREE;
10926
10927   switch (nargs)
10928     {
10929     case 0:
10930       ret = fold_builtin_0 (fndecl, ignore);
10931       break;
10932     case 1:
10933       ret = fold_builtin_1 (fndecl, args[0], ignore);
10934       break;
10935     case 2:
10936       ret = fold_builtin_2 (fndecl, args[0], args[1], ignore);
10937       break;
10938     case 3:
10939       ret = fold_builtin_3 (fndecl, args[0], args[1], args[2], ignore);
10940       break;
10941     case 4:
10942       ret = fold_builtin_4 (fndecl, args[0], args[1], args[2], args[3],
10943                             ignore);
10944       break;
10945     default:
10946       break;
10947     }
10948   if (ret)
10949     {
10950       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10951       TREE_NO_WARNING (ret) = 1;
10952       return ret;
10953     }
10954   return NULL_TREE;
10955 }
10956
10957 /* Builtins with folding operations that operate on "..." arguments
10958    need special handling; we need to store the arguments in a convenient
10959    data structure before attempting any folding.  Fortunately there are
10960    only a few builtins that fall into this category.  FNDECL is the
10961    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10962    result of the function call is ignored.  */
10963
10964 static tree
10965 fold_builtin_varargs (tree fndecl, tree exp, bool ignore ATTRIBUTE_UNUSED)
10966 {
10967   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10968   tree ret = NULL_TREE;
10969
10970   switch (fcode)
10971     {
10972     case BUILT_IN_SPRINTF_CHK:
10973     case BUILT_IN_VSPRINTF_CHK:
10974       ret = fold_builtin_sprintf_chk (exp, fcode);
10975       break;
10976
10977     case BUILT_IN_SNPRINTF_CHK:
10978     case BUILT_IN_VSNPRINTF_CHK:
10979       ret = fold_builtin_snprintf_chk (exp, NULL_TREE, fcode);
10980       break;
10981
10982     case BUILT_IN_FPCLASSIFY:
10983       ret = fold_builtin_fpclassify (exp);
10984       break;
10985
10986     default:
10987       break;
10988     }
10989   if (ret)
10990     {
10991       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10992       TREE_NO_WARNING (ret) = 1;
10993       return ret;
10994     }
10995   return NULL_TREE;
10996 }
10997
10998 /* Return true if FNDECL shouldn't be folded right now.
10999    If a built-in function has an inline attribute always_inline
11000    wrapper, defer folding it after always_inline functions have
11001    been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
11002    might not be performed.  */
11003
11004 static bool
11005 avoid_folding_inline_builtin (tree fndecl)
11006 {
11007   return (DECL_DECLARED_INLINE_P (fndecl)
11008           && DECL_DISREGARD_INLINE_LIMITS (fndecl)
11009           && cfun
11010           && !cfun->always_inline_functions_inlined
11011           && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
11012 }
11013
11014 /* A wrapper function for builtin folding that prevents warnings for
11015    "statement without effect" and the like, caused by removing the
11016    call node earlier than the warning is generated.  */
11017
11018 tree
11019 fold_call_expr (tree exp, bool ignore)
11020 {
11021   tree ret = NULL_TREE;
11022   tree fndecl = get_callee_fndecl (exp);
11023   if (fndecl
11024       && TREE_CODE (fndecl) == FUNCTION_DECL
11025       && DECL_BUILT_IN (fndecl)
11026       /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
11027          yet.  Defer folding until we see all the arguments
11028          (after inlining).  */
11029       && !CALL_EXPR_VA_ARG_PACK (exp))
11030     {
11031       int nargs = call_expr_nargs (exp);
11032
11033       /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
11034          instead last argument is __builtin_va_arg_pack ().  Defer folding
11035          even in that case, until arguments are finalized.  */
11036       if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
11037         {
11038           tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
11039           if (fndecl2
11040               && TREE_CODE (fndecl2) == FUNCTION_DECL
11041               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
11042               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
11043             return NULL_TREE;
11044         }
11045
11046       if (avoid_folding_inline_builtin (fndecl))
11047         return NULL_TREE;
11048
11049       /* FIXME: Don't use a list in this interface.  */
11050       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
11051           return targetm.fold_builtin (fndecl, CALL_EXPR_ARGS (exp), ignore);
11052       else
11053         {
11054           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
11055             {
11056               tree *args = CALL_EXPR_ARGP (exp);
11057               ret = fold_builtin_n (fndecl, args, nargs, ignore);
11058             }
11059           if (!ret)
11060             ret = fold_builtin_varargs (fndecl, exp, ignore);
11061           if (ret)
11062             {
11063               /* Propagate location information from original call to
11064                  expansion of builtin.  Otherwise things like
11065                  maybe_emit_chk_warning, that operate on the expansion
11066                  of a builtin, will use the wrong location information.  */
11067               if (CAN_HAVE_LOCATION_P (exp) && EXPR_HAS_LOCATION (exp))
11068                 {
11069                   tree realret = ret;
11070                   if (TREE_CODE (ret) == NOP_EXPR)
11071                     realret = TREE_OPERAND (ret, 0);
11072                   if (CAN_HAVE_LOCATION_P (realret)
11073                       && !EXPR_HAS_LOCATION (realret))
11074                     SET_EXPR_LOCATION (realret, EXPR_LOCATION (exp));
11075                 }
11076               return ret;
11077             }
11078         }
11079     }
11080   return NULL_TREE;
11081 }
11082
11083 /* Conveniently construct a function call expression.  FNDECL names the
11084     function to be called and ARGLIST is a TREE_LIST of arguments.  */
11085
11086 tree
11087 build_function_call_expr (tree fndecl, tree arglist)
11088 {
11089   tree fntype = TREE_TYPE (fndecl);
11090   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
11091   int n = list_length (arglist);
11092   tree *argarray = (tree *) alloca (n * sizeof (tree));
11093   int i;
11094
11095   for (i = 0; i < n; i++, arglist = TREE_CHAIN (arglist))
11096     argarray[i] = TREE_VALUE (arglist);
11097   return fold_builtin_call_array (TREE_TYPE (fntype), fn, n, argarray);
11098 }
11099
11100 /* Conveniently construct a function call expression.  FNDECL names the
11101    function to be called, N is the number of arguments, and the "..."
11102    parameters are the argument expressions.  */
11103
11104 tree
11105 build_call_expr (tree fndecl, int n, ...)
11106 {
11107   va_list ap;
11108   tree fntype = TREE_TYPE (fndecl);
11109   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
11110   tree *argarray = (tree *) alloca (n * sizeof (tree));
11111   int i;
11112
11113   va_start (ap, n);
11114   for (i = 0; i < n; i++)
11115     argarray[i] = va_arg (ap, tree);
11116   va_end (ap);
11117   return fold_builtin_call_array (TREE_TYPE (fntype), fn, n, argarray);
11118 }
11119
11120 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
11121    N arguments are passed in the array ARGARRAY.  */
11122
11123 tree
11124 fold_builtin_call_array (tree type,
11125                          tree fn,
11126                          int n,
11127                          tree *argarray)
11128 {
11129   tree ret = NULL_TREE;
11130   int i;
11131    tree exp;
11132
11133   if (TREE_CODE (fn) == ADDR_EXPR)
11134   {
11135     tree fndecl = TREE_OPERAND (fn, 0);
11136     if (TREE_CODE (fndecl) == FUNCTION_DECL
11137         && DECL_BUILT_IN (fndecl))
11138       {
11139         /* If last argument is __builtin_va_arg_pack (), arguments to this
11140            function are not finalized yet.  Defer folding until they are.  */
11141         if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
11142           {
11143             tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
11144             if (fndecl2
11145                 && TREE_CODE (fndecl2) == FUNCTION_DECL
11146                 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
11147                 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
11148               return build_call_array (type, fn, n, argarray);
11149           }
11150         if (avoid_folding_inline_builtin (fndecl))
11151           return build_call_array (type, fn, n, argarray);
11152         if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
11153           {
11154             tree arglist = NULL_TREE;
11155             for (i = n - 1; i >= 0; i--)
11156               arglist = tree_cons (NULL_TREE, argarray[i], arglist);
11157             ret = targetm.fold_builtin (fndecl, arglist, false);
11158             if (ret)
11159               return ret;
11160             return build_call_array (type, fn, n, argarray);
11161           }
11162         else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
11163           {
11164             /* First try the transformations that don't require consing up
11165                an exp.  */
11166             ret = fold_builtin_n (fndecl, argarray, n, false);
11167             if (ret)
11168               return ret;
11169           }
11170
11171         /* If we got this far, we need to build an exp.  */
11172         exp = build_call_array (type, fn, n, argarray);
11173         ret = fold_builtin_varargs (fndecl, exp, false);
11174         return ret ? ret : exp;
11175       }
11176   }
11177
11178   return build_call_array (type, fn, n, argarray);
11179 }
11180
11181 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
11182    along with N new arguments specified as the "..." parameters.  SKIP
11183    is the number of arguments in EXP to be omitted.  This function is used
11184    to do varargs-to-varargs transformations.  */
11185
11186 static tree
11187 rewrite_call_expr (tree exp, int skip, tree fndecl, int n, ...)
11188 {
11189   int oldnargs = call_expr_nargs (exp);
11190   int nargs = oldnargs - skip + n;
11191   tree fntype = TREE_TYPE (fndecl);
11192   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
11193   tree *buffer;
11194
11195   if (n > 0)
11196     {
11197       int i, j;
11198       va_list ap;
11199
11200       buffer = XALLOCAVEC (tree, nargs);
11201       va_start (ap, n);
11202       for (i = 0; i < n; i++)
11203         buffer[i] = va_arg (ap, tree);
11204       va_end (ap);
11205       for (j = skip; j < oldnargs; j++, i++)
11206         buffer[i] = CALL_EXPR_ARG (exp, j);
11207     }
11208   else
11209     buffer = CALL_EXPR_ARGP (exp) + skip;
11210
11211   return fold (build_call_array (TREE_TYPE (exp), fn, nargs, buffer));
11212 }
11213
11214 /* Validate a single argument ARG against a tree code CODE representing
11215    a type.  */
11216
11217 static bool
11218 validate_arg (const_tree arg, enum tree_code code)
11219 {
11220   if (!arg)
11221     return false;
11222   else if (code == POINTER_TYPE)
11223     return POINTER_TYPE_P (TREE_TYPE (arg));
11224   else if (code == INTEGER_TYPE)
11225     return INTEGRAL_TYPE_P (TREE_TYPE (arg));
11226   return code == TREE_CODE (TREE_TYPE (arg));
11227 }
11228
11229 /* This function validates the types of a function call argument list
11230    against a specified list of tree_codes.  If the last specifier is a 0,
11231    that represents an ellipses, otherwise the last specifier must be a
11232    VOID_TYPE.
11233
11234    This is the GIMPLE version of validate_arglist.  Eventually we want to
11235    completely convert builtins.c to work from GIMPLEs and the tree based
11236    validate_arglist will then be removed.  */
11237
11238 bool
11239 validate_gimple_arglist (const_gimple call, ...)
11240 {
11241   enum tree_code code;
11242   bool res = 0;
11243   va_list ap;
11244   const_tree arg;
11245   size_t i;
11246
11247   va_start (ap, call);
11248   i = 0;
11249
11250   do
11251     {
11252       code = (enum tree_code) va_arg (ap, int);
11253       switch (code)
11254         {
11255         case 0:
11256           /* This signifies an ellipses, any further arguments are all ok.  */
11257           res = true;
11258           goto end;
11259         case VOID_TYPE:
11260           /* This signifies an endlink, if no arguments remain, return
11261              true, otherwise return false.  */
11262           res = (i == gimple_call_num_args (call));
11263           goto end;
11264         default:
11265           /* If no parameters remain or the parameter's code does not
11266              match the specified code, return false.  Otherwise continue
11267              checking any remaining arguments.  */
11268           arg = gimple_call_arg (call, i++);
11269           if (!validate_arg (arg, code))
11270             goto end;
11271           break;
11272         }
11273     }
11274   while (1);
11275
11276   /* We need gotos here since we can only have one VA_CLOSE in a
11277      function.  */
11278  end: ;
11279   va_end (ap);
11280
11281   return res;
11282 }
11283
11284 /* This function validates the types of a function call argument list
11285    against a specified list of tree_codes.  If the last specifier is a 0,
11286    that represents an ellipses, otherwise the last specifier must be a
11287    VOID_TYPE.  */
11288
11289 bool
11290 validate_arglist (const_tree callexpr, ...)
11291 {
11292   enum tree_code code;
11293   bool res = 0;
11294   va_list ap;
11295   const_call_expr_arg_iterator iter;
11296   const_tree arg;
11297
11298   va_start (ap, callexpr);
11299   init_const_call_expr_arg_iterator (callexpr, &iter);
11300
11301   do
11302     {
11303       code = (enum tree_code) va_arg (ap, int);
11304       switch (code)
11305         {
11306         case 0:
11307           /* This signifies an ellipses, any further arguments are all ok.  */
11308           res = true;
11309           goto end;
11310         case VOID_TYPE:
11311           /* This signifies an endlink, if no arguments remain, return
11312              true, otherwise return false.  */
11313           res = !more_const_call_expr_args_p (&iter);
11314           goto end;
11315         default:
11316           /* If no parameters remain or the parameter's code does not
11317              match the specified code, return false.  Otherwise continue
11318              checking any remaining arguments.  */
11319           arg = next_const_call_expr_arg (&iter);
11320           if (!validate_arg (arg, code))
11321             goto end;
11322           break;
11323         }
11324     }
11325   while (1);
11326
11327   /* We need gotos here since we can only have one VA_CLOSE in a
11328      function.  */
11329  end: ;
11330   va_end (ap);
11331
11332   return res;
11333 }
11334
11335 /* Default target-specific builtin expander that does nothing.  */
11336
11337 rtx
11338 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11339                         rtx target ATTRIBUTE_UNUSED,
11340                         rtx subtarget ATTRIBUTE_UNUSED,
11341                         enum machine_mode mode ATTRIBUTE_UNUSED,
11342                         int ignore ATTRIBUTE_UNUSED)
11343 {
11344   return NULL_RTX;
11345 }
11346
11347 /* Returns true is EXP represents data that would potentially reside
11348    in a readonly section.  */
11349
11350 static bool
11351 readonly_data_expr (tree exp)
11352 {
11353   STRIP_NOPS (exp);
11354
11355   if (TREE_CODE (exp) != ADDR_EXPR)
11356     return false;
11357
11358   exp = get_base_address (TREE_OPERAND (exp, 0));
11359   if (!exp)
11360     return false;
11361
11362   /* Make sure we call decl_readonly_section only for trees it
11363      can handle (since it returns true for everything it doesn't
11364      understand).  */
11365   if (TREE_CODE (exp) == STRING_CST
11366       || TREE_CODE (exp) == CONSTRUCTOR
11367       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11368     return decl_readonly_section (exp, 0);
11369   else
11370     return false;
11371 }
11372
11373 /* Simplify a call to the strstr builtin.  S1 and S2 are the arguments
11374    to the call, and TYPE is its return type.
11375
11376    Return NULL_TREE if no simplification was possible, otherwise return the
11377    simplified form of the call as a tree.
11378
11379    The simplified form may be a constant or other expression which
11380    computes the same value, but in a more efficient manner (including
11381    calls to other builtin functions).
11382
11383    The call may contain arguments which need to be evaluated, but
11384    which are not useful to determine the result of the call.  In
11385    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11386    COMPOUND_EXPR will be an argument which must be evaluated.
11387    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11388    COMPOUND_EXPR in the chain will contain the tree for the simplified
11389    form of the builtin function call.  */
11390
11391 static tree
11392 fold_builtin_strstr (tree s1, tree s2, tree type)
11393 {
11394   if (!validate_arg (s1, POINTER_TYPE)
11395       || !validate_arg (s2, POINTER_TYPE))
11396     return NULL_TREE;
11397   else
11398     {
11399       tree fn;
11400       const char *p1, *p2;
11401
11402       p2 = c_getstr (s2);
11403       if (p2 == NULL)
11404         return NULL_TREE;
11405
11406       p1 = c_getstr (s1);
11407       if (p1 != NULL)
11408         {
11409           const char *r = strstr (p1, p2);
11410           tree tem;
11411
11412           if (r == NULL)
11413             return build_int_cst (TREE_TYPE (s1), 0);
11414
11415           /* Return an offset into the constant string argument.  */
11416           tem = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (s1),
11417                              s1, size_int (r - p1));
11418           return fold_convert (type, tem);
11419         }
11420
11421       /* The argument is const char *, and the result is char *, so we need
11422          a type conversion here to avoid a warning.  */
11423       if (p2[0] == '\0')
11424         return fold_convert (type, s1);
11425
11426       if (p2[1] != '\0')
11427         return NULL_TREE;
11428
11429       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11430       if (!fn)
11431         return NULL_TREE;
11432
11433       /* New argument list transforming strstr(s1, s2) to
11434          strchr(s1, s2[0]).  */
11435       return build_call_expr (fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11436     }
11437 }
11438
11439 /* Simplify a call to the strchr builtin.  S1 and S2 are the arguments to
11440    the call, and TYPE is its return type.
11441
11442    Return NULL_TREE if no simplification was possible, otherwise return the
11443    simplified form of the call as a tree.
11444
11445    The simplified form may be a constant or other expression which
11446    computes the same value, but in a more efficient manner (including
11447    calls to other builtin functions).
11448
11449    The call may contain arguments which need to be evaluated, but
11450    which are not useful to determine the result of the call.  In
11451    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11452    COMPOUND_EXPR will be an argument which must be evaluated.
11453    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11454    COMPOUND_EXPR in the chain will contain the tree for the simplified
11455    form of the builtin function call.  */
11456
11457 static tree
11458 fold_builtin_strchr (tree s1, tree s2, tree type)
11459 {
11460   if (!validate_arg (s1, POINTER_TYPE)
11461       || !validate_arg (s2, INTEGER_TYPE))
11462     return NULL_TREE;
11463   else
11464     {
11465       const char *p1;
11466
11467       if (TREE_CODE (s2) != INTEGER_CST)
11468         return NULL_TREE;
11469
11470       p1 = c_getstr (s1);
11471       if (p1 != NULL)
11472         {
11473           char c;
11474           const char *r;
11475           tree tem;
11476
11477           if (target_char_cast (s2, &c))
11478             return NULL_TREE;
11479
11480           r = strchr (p1, c);
11481
11482           if (r == NULL)
11483             return build_int_cst (TREE_TYPE (s1), 0);
11484
11485           /* Return an offset into the constant string argument.  */
11486           tem = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (s1),
11487                              s1, size_int (r - p1));
11488           return fold_convert (type, tem);
11489         }
11490       return NULL_TREE;
11491     }
11492 }
11493
11494 /* Simplify a call to the strrchr builtin.  S1 and S2 are the arguments to
11495    the call, and TYPE is its return type.
11496
11497    Return NULL_TREE if no simplification was possible, otherwise return the
11498    simplified form of the call as a tree.
11499
11500    The simplified form may be a constant or other expression which
11501    computes the same value, but in a more efficient manner (including
11502    calls to other builtin functions).
11503
11504    The call may contain arguments which need to be evaluated, but
11505    which are not useful to determine the result of the call.  In
11506    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11507    COMPOUND_EXPR will be an argument which must be evaluated.
11508    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11509    COMPOUND_EXPR in the chain will contain the tree for the simplified
11510    form of the builtin function call.  */
11511
11512 static tree
11513 fold_builtin_strrchr (tree s1, tree s2, tree type)
11514 {
11515   if (!validate_arg (s1, POINTER_TYPE)
11516       || !validate_arg (s2, INTEGER_TYPE))
11517     return NULL_TREE;
11518   else
11519     {
11520       tree fn;
11521       const char *p1;
11522
11523       if (TREE_CODE (s2) != INTEGER_CST)
11524         return NULL_TREE;
11525
11526       p1 = c_getstr (s1);
11527       if (p1 != NULL)
11528         {
11529           char c;
11530           const char *r;
11531           tree tem;
11532
11533           if (target_char_cast (s2, &c))
11534             return NULL_TREE;
11535
11536           r = strrchr (p1, c);
11537
11538           if (r == NULL)
11539             return build_int_cst (TREE_TYPE (s1), 0);
11540
11541           /* Return an offset into the constant string argument.  */
11542           tem = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (s1),
11543                              s1, size_int (r - p1));
11544           return fold_convert (type, tem);
11545         }
11546
11547       if (! integer_zerop (s2))
11548         return NULL_TREE;
11549
11550       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11551       if (!fn)
11552         return NULL_TREE;
11553
11554       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
11555       return build_call_expr (fn, 2, s1, s2);
11556     }
11557 }
11558
11559 /* Simplify a call to the strpbrk builtin.  S1 and S2 are the arguments
11560    to the call, and TYPE is its return type.
11561
11562    Return NULL_TREE if no simplification was possible, otherwise return the
11563    simplified form of the call as a tree.
11564
11565    The simplified form may be a constant or other expression which
11566    computes the same value, but in a more efficient manner (including
11567    calls to other builtin functions).
11568
11569    The call may contain arguments which need to be evaluated, but
11570    which are not useful to determine the result of the call.  In
11571    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11572    COMPOUND_EXPR will be an argument which must be evaluated.
11573    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11574    COMPOUND_EXPR in the chain will contain the tree for the simplified
11575    form of the builtin function call.  */
11576
11577 static tree
11578 fold_builtin_strpbrk (tree s1, tree s2, tree type)
11579 {
11580   if (!validate_arg (s1, POINTER_TYPE)
11581       || !validate_arg (s2, POINTER_TYPE))
11582     return NULL_TREE;
11583   else
11584     {
11585       tree fn;
11586       const char *p1, *p2;
11587
11588       p2 = c_getstr (s2);
11589       if (p2 == NULL)
11590         return NULL_TREE;
11591
11592       p1 = c_getstr (s1);
11593       if (p1 != NULL)
11594         {
11595           const char *r = strpbrk (p1, p2);
11596           tree tem;
11597
11598           if (r == NULL)
11599             return build_int_cst (TREE_TYPE (s1), 0);
11600
11601           /* Return an offset into the constant string argument.  */
11602           tem = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (s1),
11603                              s1, size_int (r - p1));
11604           return fold_convert (type, tem);
11605         }
11606
11607       if (p2[0] == '\0')
11608         /* strpbrk(x, "") == NULL.
11609            Evaluate and ignore s1 in case it had side-effects.  */
11610         return omit_one_operand (TREE_TYPE (s1), integer_zero_node, s1);
11611
11612       if (p2[1] != '\0')
11613         return NULL_TREE;  /* Really call strpbrk.  */
11614
11615       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11616       if (!fn)
11617         return NULL_TREE;
11618
11619       /* New argument list transforming strpbrk(s1, s2) to
11620          strchr(s1, s2[0]).  */
11621       return build_call_expr (fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11622     }
11623 }
11624
11625 /* Simplify a call to the strcat builtin.  DST and SRC are the arguments
11626    to the call.
11627
11628    Return NULL_TREE if no simplification was possible, otherwise return the
11629    simplified form of the call as a tree.
11630
11631    The simplified form may be a constant or other expression which
11632    computes the same value, but in a more efficient manner (including
11633    calls to other builtin functions).
11634
11635    The call may contain arguments which need to be evaluated, but
11636    which are not useful to determine the result of the call.  In
11637    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11638    COMPOUND_EXPR will be an argument which must be evaluated.
11639    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11640    COMPOUND_EXPR in the chain will contain the tree for the simplified
11641    form of the builtin function call.  */
11642
11643 static tree
11644 fold_builtin_strcat (tree dst, tree src)
11645 {
11646   if (!validate_arg (dst, POINTER_TYPE)
11647       || !validate_arg (src, POINTER_TYPE))
11648     return NULL_TREE;
11649   else
11650     {
11651       const char *p = c_getstr (src);
11652
11653       /* If the string length is zero, return the dst parameter.  */
11654       if (p && *p == '\0')
11655         return dst;
11656
11657       return NULL_TREE;
11658     }
11659 }
11660
11661 /* Simplify a call to the strncat builtin.  DST, SRC, and LEN are the
11662    arguments to the call.
11663
11664    Return NULL_TREE if no simplification was possible, otherwise return the
11665    simplified form of the call as a tree.
11666
11667    The simplified form may be a constant or other expression which
11668    computes the same value, but in a more efficient manner (including
11669    calls to other builtin functions).
11670
11671    The call may contain arguments which need to be evaluated, but
11672    which are not useful to determine the result of the call.  In
11673    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11674    COMPOUND_EXPR will be an argument which must be evaluated.
11675    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11676    COMPOUND_EXPR in the chain will contain the tree for the simplified
11677    form of the builtin function call.  */
11678
11679 static tree
11680 fold_builtin_strncat (tree dst, tree src, tree len)
11681 {
11682   if (!validate_arg (dst, POINTER_TYPE)
11683       || !validate_arg (src, POINTER_TYPE)
11684       || !validate_arg (len, INTEGER_TYPE))
11685     return NULL_TREE;
11686   else
11687     {
11688       const char *p = c_getstr (src);
11689
11690       /* If the requested length is zero, or the src parameter string
11691          length is zero, return the dst parameter.  */
11692       if (integer_zerop (len) || (p && *p == '\0'))
11693         return omit_two_operands (TREE_TYPE (dst), dst, src, len);
11694
11695       /* If the requested len is greater than or equal to the string
11696          length, call strcat.  */
11697       if (TREE_CODE (len) == INTEGER_CST && p
11698           && compare_tree_int (len, strlen (p)) >= 0)
11699         {
11700           tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
11701
11702           /* If the replacement _DECL isn't initialized, don't do the
11703              transformation.  */
11704           if (!fn)
11705             return NULL_TREE;
11706
11707           return build_call_expr (fn, 2, dst, src);
11708         }
11709       return NULL_TREE;
11710     }
11711 }
11712
11713 /* Simplify a call to the strspn builtin.  S1 and S2 are the arguments
11714    to the call.
11715
11716    Return NULL_TREE if no simplification was possible, otherwise return the
11717    simplified form of the call as a tree.
11718
11719    The simplified form may be a constant or other expression which
11720    computes the same value, but in a more efficient manner (including
11721    calls to other builtin functions).
11722
11723    The call may contain arguments which need to be evaluated, but
11724    which are not useful to determine the result of the call.  In
11725    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11726    COMPOUND_EXPR will be an argument which must be evaluated.
11727    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11728    COMPOUND_EXPR in the chain will contain the tree for the simplified
11729    form of the builtin function call.  */
11730
11731 static tree
11732 fold_builtin_strspn (tree s1, tree s2)
11733 {
11734   if (!validate_arg (s1, POINTER_TYPE)
11735       || !validate_arg (s2, POINTER_TYPE))
11736     return NULL_TREE;
11737   else
11738     {
11739       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11740
11741       /* If both arguments are constants, evaluate at compile-time.  */
11742       if (p1 && p2)
11743         {
11744           const size_t r = strspn (p1, p2);
11745           return size_int (r);
11746         }
11747
11748       /* If either argument is "", return NULL_TREE.  */
11749       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11750         /* Evaluate and ignore both arguments in case either one has
11751            side-effects.  */
11752         return omit_two_operands (size_type_node, size_zero_node,
11753                                   s1, s2);
11754       return NULL_TREE;
11755     }
11756 }
11757
11758 /* Simplify a call to the strcspn builtin.  S1 and S2 are the arguments
11759    to the call.
11760
11761    Return NULL_TREE if no simplification was possible, otherwise return the
11762    simplified form of the call as a tree.
11763
11764    The simplified form may be a constant or other expression which
11765    computes the same value, but in a more efficient manner (including
11766    calls to other builtin functions).
11767
11768    The call may contain arguments which need to be evaluated, but
11769    which are not useful to determine the result of the call.  In
11770    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11771    COMPOUND_EXPR will be an argument which must be evaluated.
11772    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11773    COMPOUND_EXPR in the chain will contain the tree for the simplified
11774    form of the builtin function call.  */
11775
11776 static tree
11777 fold_builtin_strcspn (tree s1, tree s2)
11778 {
11779   if (!validate_arg (s1, POINTER_TYPE)
11780       || !validate_arg (s2, POINTER_TYPE))
11781     return NULL_TREE;
11782   else
11783     {
11784       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11785
11786       /* If both arguments are constants, evaluate at compile-time.  */
11787       if (p1 && p2)
11788         {
11789           const size_t r = strcspn (p1, p2);
11790           return size_int (r);
11791         }
11792
11793       /* If the first argument is "", return NULL_TREE.  */
11794       if (p1 && *p1 == '\0')
11795         {
11796           /* Evaluate and ignore argument s2 in case it has
11797              side-effects.  */
11798           return omit_one_operand (size_type_node,
11799                                    size_zero_node, s2);
11800         }
11801
11802       /* If the second argument is "", return __builtin_strlen(s1).  */
11803       if (p2 && *p2 == '\0')
11804         {
11805           tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11806
11807           /* If the replacement _DECL isn't initialized, don't do the
11808              transformation.  */
11809           if (!fn)
11810             return NULL_TREE;
11811
11812           return build_call_expr (fn, 1, s1);
11813         }
11814       return NULL_TREE;
11815     }
11816 }
11817
11818 /* Fold a call to the fputs builtin.  ARG0 and ARG1 are the arguments
11819    to the call.  IGNORE is true if the value returned
11820    by the builtin will be ignored.  UNLOCKED is true is true if this
11821    actually a call to fputs_unlocked.  If LEN in non-NULL, it represents
11822    the known length of the string.  Return NULL_TREE if no simplification
11823    was possible.  */
11824
11825 tree
11826 fold_builtin_fputs (tree arg0, tree arg1, bool ignore, bool unlocked, tree len)
11827 {
11828   /* If we're using an unlocked function, assume the other unlocked
11829      functions exist explicitly.  */
11830   tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
11831     : implicit_built_in_decls[BUILT_IN_FPUTC];
11832   tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
11833     : implicit_built_in_decls[BUILT_IN_FWRITE];
11834
11835   /* If the return value is used, don't do the transformation.  */
11836   if (!ignore)
11837     return NULL_TREE;
11838
11839   /* Verify the arguments in the original call.  */
11840   if (!validate_arg (arg0, POINTER_TYPE)
11841       || !validate_arg (arg1, POINTER_TYPE))
11842     return NULL_TREE;
11843
11844   if (! len)
11845     len = c_strlen (arg0, 0);
11846
11847   /* Get the length of the string passed to fputs.  If the length
11848      can't be determined, punt.  */
11849   if (!len
11850       || TREE_CODE (len) != INTEGER_CST)
11851     return NULL_TREE;
11852
11853   switch (compare_tree_int (len, 1))
11854     {
11855     case -1: /* length is 0, delete the call entirely .  */
11856       return omit_one_operand (integer_type_node, integer_zero_node, arg1);;
11857
11858     case 0: /* length is 1, call fputc.  */
11859       {
11860         const char *p = c_getstr (arg0);
11861
11862         if (p != NULL)
11863           {
11864             if (fn_fputc)
11865               return build_call_expr (fn_fputc, 2,
11866                                       build_int_cst (NULL_TREE, p[0]), arg1);
11867             else
11868               return NULL_TREE;
11869           }
11870       }
11871       /* FALLTHROUGH */
11872     case 1: /* length is greater than 1, call fwrite.  */
11873       {
11874         /* If optimizing for size keep fputs.  */
11875         if (optimize_function_for_size_p (cfun))
11876           return NULL_TREE;
11877         /* New argument list transforming fputs(string, stream) to
11878            fwrite(string, 1, len, stream).  */
11879         if (fn_fwrite)
11880           return build_call_expr (fn_fwrite, 4, arg0, size_one_node, len, arg1);
11881         else
11882           return NULL_TREE;
11883       }
11884     default:
11885       gcc_unreachable ();
11886     }
11887   return NULL_TREE;
11888 }
11889
11890 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11891    produced.  False otherwise.  This is done so that we don't output the error
11892    or warning twice or three times.  */
11893
11894 bool
11895 fold_builtin_next_arg (tree exp, bool va_start_p)
11896 {
11897   tree fntype = TREE_TYPE (current_function_decl);
11898   int nargs = call_expr_nargs (exp);
11899   tree arg;
11900
11901   if (TYPE_ARG_TYPES (fntype) == 0
11902       || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
11903           == void_type_node))
11904     {
11905       error ("%<va_start%> used in function with fixed args");
11906       return true;
11907     }
11908
11909   if (va_start_p)
11910     {
11911       if (va_start_p && (nargs != 2))
11912         {
11913           error ("wrong number of arguments to function %<va_start%>");
11914           return true;
11915         }
11916       arg = CALL_EXPR_ARG (exp, 1);
11917     }
11918   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11919      when we checked the arguments and if needed issued a warning.  */
11920   else
11921     {
11922       if (nargs == 0)
11923         {
11924           /* Evidently an out of date version of <stdarg.h>; can't validate
11925              va_start's second argument, but can still work as intended.  */
11926           warning (0, "%<__builtin_next_arg%> called without an argument");
11927           return true;
11928         }
11929       else if (nargs > 1)
11930         {
11931           error ("wrong number of arguments to function %<__builtin_next_arg%>");
11932           return true;
11933         }
11934       arg = CALL_EXPR_ARG (exp, 0);
11935     }
11936
11937   if (TREE_CODE (arg) == SSA_NAME)
11938     arg = SSA_NAME_VAR (arg);
11939
11940   /* We destructively modify the call to be __builtin_va_start (ap, 0)
11941      or __builtin_next_arg (0) the first time we see it, after checking
11942      the arguments and if needed issuing a warning.  */
11943   if (!integer_zerop (arg))
11944     {
11945       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
11946
11947       /* Strip off all nops for the sake of the comparison.  This
11948          is not quite the same as STRIP_NOPS.  It does more.
11949          We must also strip off INDIRECT_EXPR for C++ reference
11950          parameters.  */
11951       while (CONVERT_EXPR_P (arg)
11952              || TREE_CODE (arg) == INDIRECT_REF)
11953         arg = TREE_OPERAND (arg, 0);
11954       if (arg != last_parm)
11955         {
11956           /* FIXME: Sometimes with the tree optimizers we can get the
11957              not the last argument even though the user used the last
11958              argument.  We just warn and set the arg to be the last
11959              argument so that we will get wrong-code because of
11960              it.  */
11961           warning (0, "second parameter of %<va_start%> not last named argument");
11962         }
11963
11964       /* Undefined by C99 7.15.1.4p4 (va_start):
11965          "If the parameter parmN is declared with the register storage
11966          class, with a function or array type, or with a type that is
11967          not compatible with the type that results after application of
11968          the default argument promotions, the behavior is undefined."
11969       */
11970       else if (DECL_REGISTER (arg))
11971         warning (0, "undefined behaviour when second parameter of "
11972                  "%<va_start%> is declared with %<register%> storage");
11973
11974       /* We want to verify the second parameter just once before the tree
11975          optimizers are run and then avoid keeping it in the tree,
11976          as otherwise we could warn even for correct code like:
11977          void foo (int i, ...)
11978          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
11979       if (va_start_p)
11980         CALL_EXPR_ARG (exp, 1) = integer_zero_node;
11981       else
11982         CALL_EXPR_ARG (exp, 0) = integer_zero_node;
11983     }
11984   return false;
11985 }
11986
11987
11988 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11989    ORIG may be null if this is a 2-argument call.  We don't attempt to
11990    simplify calls with more than 3 arguments.
11991
11992    Return NULL_TREE if no simplification was possible, otherwise return the
11993    simplified form of the call as a tree.  If IGNORED is true, it means that
11994    the caller does not use the returned value of the function.  */
11995
11996 static tree
11997 fold_builtin_sprintf (tree dest, tree fmt, tree orig, int ignored)
11998 {
11999   tree call, retval;
12000   const char *fmt_str = NULL;
12001
12002   /* Verify the required arguments in the original call.  We deal with two
12003      types of sprintf() calls: 'sprintf (str, fmt)' and
12004      'sprintf (dest, "%s", orig)'.  */
12005   if (!validate_arg (dest, POINTER_TYPE)
12006       || !validate_arg (fmt, POINTER_TYPE))
12007     return NULL_TREE;
12008   if (orig && !validate_arg (orig, POINTER_TYPE))
12009     return NULL_TREE;
12010
12011   /* Check whether the format is a literal string constant.  */
12012   fmt_str = c_getstr (fmt);
12013   if (fmt_str == NULL)
12014     return NULL_TREE;
12015
12016   call = NULL_TREE;
12017   retval = NULL_TREE;
12018
12019   if (!init_target_chars ())
12020     return NULL_TREE;
12021
12022   /* If the format doesn't contain % args or %%, use strcpy.  */
12023   if (strchr (fmt_str, target_percent) == NULL)
12024     {
12025       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
12026
12027       if (!fn)
12028         return NULL_TREE;
12029
12030       /* Don't optimize sprintf (buf, "abc", ptr++).  */
12031       if (orig)
12032         return NULL_TREE;
12033
12034       /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
12035          'format' is known to contain no % formats.  */
12036       call = build_call_expr (fn, 2, dest, fmt);
12037       if (!ignored)
12038         retval = build_int_cst (NULL_TREE, strlen (fmt_str));
12039     }
12040
12041   /* If the format is "%s", use strcpy if the result isn't used.  */
12042   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
12043     {
12044       tree fn;
12045       fn = implicit_built_in_decls[BUILT_IN_STRCPY];
12046
12047       if (!fn)
12048         return NULL_TREE;
12049
12050       /* Don't crash on sprintf (str1, "%s").  */
12051       if (!orig)
12052         return NULL_TREE;
12053
12054       /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2).  */
12055       if (!ignored)
12056         {
12057           retval = c_strlen (orig, 1);
12058           if (!retval || TREE_CODE (retval) != INTEGER_CST)
12059             return NULL_TREE;
12060         }
12061       call = build_call_expr (fn, 2, dest, orig);
12062     }
12063
12064   if (call && retval)
12065     {
12066       retval = fold_convert
12067         (TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
12068          retval);
12069       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
12070     }
12071   else
12072     return call;
12073 }
12074
12075 /* Expand a call EXP to __builtin_object_size.  */
12076
12077 rtx
12078 expand_builtin_object_size (tree exp)
12079 {
12080   tree ost;
12081   int object_size_type;
12082   tree fndecl = get_callee_fndecl (exp);
12083
12084   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
12085     {
12086       error ("%Kfirst argument of %D must be a pointer, second integer constant",
12087              exp, fndecl);
12088       expand_builtin_trap ();
12089       return const0_rtx;
12090     }
12091
12092   ost = CALL_EXPR_ARG (exp, 1);
12093   STRIP_NOPS (ost);
12094
12095   if (TREE_CODE (ost) != INTEGER_CST
12096       || tree_int_cst_sgn (ost) < 0
12097       || compare_tree_int (ost, 3) > 0)
12098     {
12099       error ("%Klast argument of %D is not integer constant between 0 and 3",
12100              exp, fndecl);
12101       expand_builtin_trap ();
12102       return const0_rtx;
12103     }
12104
12105   object_size_type = tree_low_cst (ost, 0);
12106
12107   return object_size_type < 2 ? constm1_rtx : const0_rtx;
12108 }
12109
12110 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12111    FCODE is the BUILT_IN_* to use.
12112    Return NULL_RTX if we failed; the caller should emit a normal call,
12113    otherwise try to get the result in TARGET, if convenient (and in
12114    mode MODE if that's convenient).  */
12115
12116 static rtx
12117 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
12118                            enum built_in_function fcode)
12119 {
12120   tree dest, src, len, size;
12121
12122   if (!validate_arglist (exp,
12123                          POINTER_TYPE,
12124                          fcode == BUILT_IN_MEMSET_CHK
12125                          ? INTEGER_TYPE : POINTER_TYPE,
12126                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
12127     return NULL_RTX;
12128
12129   dest = CALL_EXPR_ARG (exp, 0);
12130   src = CALL_EXPR_ARG (exp, 1);
12131   len = CALL_EXPR_ARG (exp, 2);
12132   size = CALL_EXPR_ARG (exp, 3);
12133
12134   if (! host_integerp (size, 1))
12135     return NULL_RTX;
12136
12137   if (host_integerp (len, 1) || integer_all_onesp (size))
12138     {
12139       tree fn;
12140
12141       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
12142         {
12143           warning_at (tree_nonartificial_location (exp),
12144                       0, "%Kcall to %D will always overflow destination buffer",
12145                       exp, get_callee_fndecl (exp));
12146           return NULL_RTX;
12147         }
12148
12149       fn = NULL_TREE;
12150       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12151          mem{cpy,pcpy,move,set} is available.  */
12152       switch (fcode)
12153         {
12154         case BUILT_IN_MEMCPY_CHK:
12155           fn = built_in_decls[BUILT_IN_MEMCPY];
12156           break;
12157         case BUILT_IN_MEMPCPY_CHK:
12158           fn = built_in_decls[BUILT_IN_MEMPCPY];
12159           break;
12160         case BUILT_IN_MEMMOVE_CHK:
12161           fn = built_in_decls[BUILT_IN_MEMMOVE];
12162           break;
12163         case BUILT_IN_MEMSET_CHK:
12164           fn = built_in_decls[BUILT_IN_MEMSET];
12165           break;
12166         default:
12167           break;
12168         }
12169
12170       if (! fn)
12171         return NULL_RTX;
12172
12173       fn = build_call_expr (fn, 3, dest, src, len);
12174       STRIP_TYPE_NOPS (fn);
12175       while (TREE_CODE (fn) == COMPOUND_EXPR)
12176         {
12177           expand_expr (TREE_OPERAND (fn, 0), const0_rtx, VOIDmode,
12178                        EXPAND_NORMAL);
12179           fn = TREE_OPERAND (fn, 1);
12180         }
12181       if (TREE_CODE (fn) == CALL_EXPR)
12182         CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12183       return expand_expr (fn, target, mode, EXPAND_NORMAL);
12184     }
12185   else if (fcode == BUILT_IN_MEMSET_CHK)
12186     return NULL_RTX;
12187   else
12188     {
12189       unsigned int dest_align
12190         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
12191
12192       /* If DEST is not a pointer type, call the normal function.  */
12193       if (dest_align == 0)
12194         return NULL_RTX;
12195
12196       /* If SRC and DEST are the same (and not volatile), do nothing.  */
12197       if (operand_equal_p (src, dest, 0))
12198         {
12199           tree expr;
12200
12201           if (fcode != BUILT_IN_MEMPCPY_CHK)
12202             {
12203               /* Evaluate and ignore LEN in case it has side-effects.  */
12204               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
12205               return expand_expr (dest, target, mode, EXPAND_NORMAL);
12206             }
12207
12208           expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
12209           return expand_expr (expr, target, mode, EXPAND_NORMAL);
12210         }
12211
12212       /* __memmove_chk special case.  */
12213       if (fcode == BUILT_IN_MEMMOVE_CHK)
12214         {
12215           unsigned int src_align
12216             = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
12217
12218           if (src_align == 0)
12219             return NULL_RTX;
12220
12221           /* If src is categorized for a readonly section we can use
12222              normal __memcpy_chk.  */
12223           if (readonly_data_expr (src))
12224             {
12225               tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12226               if (!fn)
12227                 return NULL_RTX;
12228               fn = build_call_expr (fn, 4, dest, src, len, size);
12229               STRIP_TYPE_NOPS (fn);
12230               while (TREE_CODE (fn) == COMPOUND_EXPR)
12231                 {
12232                   expand_expr (TREE_OPERAND (fn, 0), const0_rtx, VOIDmode,
12233                                EXPAND_NORMAL);
12234                   fn = TREE_OPERAND (fn, 1);
12235                 }
12236               if (TREE_CODE (fn) == CALL_EXPR)
12237                 CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12238               return expand_expr (fn, target, mode, EXPAND_NORMAL);
12239             }
12240         }
12241       return NULL_RTX;
12242     }
12243 }
12244
12245 /* Emit warning if a buffer overflow is detected at compile time.  */
12246
12247 static void
12248 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
12249 {
12250   int is_strlen = 0;
12251   tree len, size;
12252   location_t loc = tree_nonartificial_location (exp);
12253
12254   switch (fcode)
12255     {
12256     case BUILT_IN_STRCPY_CHK:
12257     case BUILT_IN_STPCPY_CHK:
12258     /* For __strcat_chk the warning will be emitted only if overflowing
12259        by at least strlen (dest) + 1 bytes.  */
12260     case BUILT_IN_STRCAT_CHK:
12261       len = CALL_EXPR_ARG (exp, 1);
12262       size = CALL_EXPR_ARG (exp, 2);
12263       is_strlen = 1;
12264       break;
12265     case BUILT_IN_STRNCAT_CHK:
12266     case BUILT_IN_STRNCPY_CHK:
12267       len = CALL_EXPR_ARG (exp, 2);
12268       size = CALL_EXPR_ARG (exp, 3);
12269       break;
12270     case BUILT_IN_SNPRINTF_CHK:
12271     case BUILT_IN_VSNPRINTF_CHK:
12272       len = CALL_EXPR_ARG (exp, 1);
12273       size = CALL_EXPR_ARG (exp, 3);
12274       break;
12275     default:
12276       gcc_unreachable ();
12277     }
12278
12279   if (!len || !size)
12280     return;
12281
12282   if (! host_integerp (size, 1) || integer_all_onesp (size))
12283     return;
12284
12285   if (is_strlen)
12286     {
12287       len = c_strlen (len, 1);
12288       if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12289         return;
12290     }
12291   else if (fcode == BUILT_IN_STRNCAT_CHK)
12292     {
12293       tree src = CALL_EXPR_ARG (exp, 1);
12294       if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12295         return;
12296       src = c_strlen (src, 1);
12297       if (! src || ! host_integerp (src, 1))
12298         {
12299           warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12300                       exp, get_callee_fndecl (exp));
12301           return;
12302         }
12303       else if (tree_int_cst_lt (src, size))
12304         return;
12305     }
12306   else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12307     return;
12308
12309   warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12310               exp, get_callee_fndecl (exp));
12311 }
12312
12313 /* Emit warning if a buffer overflow is detected at compile time
12314    in __sprintf_chk/__vsprintf_chk calls.  */
12315
12316 static void
12317 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12318 {
12319   tree dest, size, len, fmt, flag;
12320   const char *fmt_str;
12321   int nargs = call_expr_nargs (exp);
12322
12323   /* Verify the required arguments in the original call.  */
12324
12325   if (nargs < 4)
12326     return;
12327   dest = CALL_EXPR_ARG (exp, 0);
12328   flag = CALL_EXPR_ARG (exp, 1);
12329   size = CALL_EXPR_ARG (exp, 2);
12330   fmt = CALL_EXPR_ARG (exp, 3);
12331
12332   if (! host_integerp (size, 1) || integer_all_onesp (size))
12333     return;
12334
12335   /* Check whether the format is a literal string constant.  */
12336   fmt_str = c_getstr (fmt);
12337   if (fmt_str == NULL)
12338     return;
12339
12340   if (!init_target_chars ())
12341     return;
12342
12343   /* If the format doesn't contain % args or %%, we know its size.  */
12344   if (strchr (fmt_str, target_percent) == 0)
12345     len = build_int_cstu (size_type_node, strlen (fmt_str));
12346   /* If the format is "%s" and first ... argument is a string literal,
12347      we know it too.  */
12348   else if (fcode == BUILT_IN_SPRINTF_CHK
12349            && strcmp (fmt_str, target_percent_s) == 0)
12350     {
12351       tree arg;
12352
12353       if (nargs < 5)
12354         return;
12355       arg = CALL_EXPR_ARG (exp, 4);
12356       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12357         return;
12358
12359       len = c_strlen (arg, 1);
12360       if (!len || ! host_integerp (len, 1))
12361         return;
12362     }
12363   else
12364     return;
12365
12366   if (! tree_int_cst_lt (len, size))
12367     warning_at (tree_nonartificial_location (exp),
12368                 0, "%Kcall to %D will always overflow destination buffer",
12369                 exp, get_callee_fndecl (exp));
12370 }
12371
12372 /* Emit warning if a free is called with address of a variable.  */
12373
12374 static void
12375 maybe_emit_free_warning (tree exp)
12376 {
12377   tree arg = CALL_EXPR_ARG (exp, 0);
12378
12379   STRIP_NOPS (arg);
12380   if (TREE_CODE (arg) != ADDR_EXPR)
12381     return;
12382
12383   arg = get_base_address (TREE_OPERAND (arg, 0));
12384   if (arg == NULL || INDIRECT_REF_P (arg))
12385     return;
12386
12387   if (SSA_VAR_P (arg))
12388     warning_at (tree_nonartificial_location (exp),
12389                 0, "%Kattempt to free a non-heap object %qD", exp, arg);
12390   else
12391     warning_at (tree_nonartificial_location (exp),
12392                 0, "%Kattempt to free a non-heap object", exp);
12393 }
12394
12395 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12396    if possible.  */
12397
12398 tree
12399 fold_builtin_object_size (tree ptr, tree ost)
12400 {
12401   tree ret = NULL_TREE;
12402   int object_size_type;
12403
12404   if (!validate_arg (ptr, POINTER_TYPE)
12405       || !validate_arg (ost, INTEGER_TYPE))
12406     return NULL_TREE;
12407
12408   STRIP_NOPS (ost);
12409
12410   if (TREE_CODE (ost) != INTEGER_CST
12411       || tree_int_cst_sgn (ost) < 0
12412       || compare_tree_int (ost, 3) > 0)
12413     return NULL_TREE;
12414
12415   object_size_type = tree_low_cst (ost, 0);
12416
12417   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12418      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12419      and (size_t) 0 for types 2 and 3.  */
12420   if (TREE_SIDE_EFFECTS (ptr))
12421     return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12422
12423   if (TREE_CODE (ptr) == ADDR_EXPR)
12424     ret = build_int_cstu (size_type_node,
12425                           compute_builtin_object_size (ptr, object_size_type));
12426
12427   else if (TREE_CODE (ptr) == SSA_NAME)
12428     {
12429       unsigned HOST_WIDE_INT bytes;
12430
12431       /* If object size is not known yet, delay folding until
12432        later.  Maybe subsequent passes will help determining
12433        it.  */
12434       bytes = compute_builtin_object_size (ptr, object_size_type);
12435       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2
12436                                              ? -1 : 0))
12437         ret = build_int_cstu (size_type_node, bytes);
12438     }
12439
12440   if (ret)
12441     {
12442       unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (ret);
12443       HOST_WIDE_INT high = TREE_INT_CST_HIGH (ret);
12444       if (fit_double_type (low, high, &low, &high, TREE_TYPE (ret)))
12445         ret = NULL_TREE;
12446     }
12447
12448   return ret;
12449 }
12450
12451 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12452    DEST, SRC, LEN, and SIZE are the arguments to the call.
12453    IGNORE is true, if return value can be ignored.  FCODE is the BUILT_IN_*
12454    code of the builtin.  If MAXLEN is not NULL, it is maximum length
12455    passed as third argument.  */
12456
12457 tree
12458 fold_builtin_memory_chk (tree fndecl,
12459                          tree dest, tree src, tree len, tree size,
12460                          tree maxlen, bool ignore,
12461                          enum built_in_function fcode)
12462 {
12463   tree fn;
12464
12465   if (!validate_arg (dest, POINTER_TYPE)
12466       || !validate_arg (src,
12467                         (fcode == BUILT_IN_MEMSET_CHK
12468                          ? INTEGER_TYPE : POINTER_TYPE))
12469       || !validate_arg (len, INTEGER_TYPE)
12470       || !validate_arg (size, INTEGER_TYPE))
12471     return NULL_TREE;
12472
12473   /* If SRC and DEST are the same (and not volatile), return DEST
12474      (resp. DEST+LEN for __mempcpy_chk).  */
12475   if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12476     {
12477       if (fcode != BUILT_IN_MEMPCPY_CHK)
12478         return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12479       else
12480         {
12481           tree temp = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
12482           return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), temp);
12483         }
12484     }
12485
12486   if (! host_integerp (size, 1))
12487     return NULL_TREE;
12488
12489   if (! integer_all_onesp (size))
12490     {
12491       if (! host_integerp (len, 1))
12492         {
12493           /* If LEN is not constant, try MAXLEN too.
12494              For MAXLEN only allow optimizing into non-_ocs function
12495              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12496           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12497             {
12498               if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12499                 {
12500                   /* (void) __mempcpy_chk () can be optimized into
12501                      (void) __memcpy_chk ().  */
12502                   fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12503                   if (!fn)
12504                     return NULL_TREE;
12505
12506                   return build_call_expr (fn, 4, dest, src, len, size);
12507                 }
12508               return NULL_TREE;
12509             }
12510         }
12511       else
12512         maxlen = len;
12513
12514       if (tree_int_cst_lt (size, maxlen))
12515         return NULL_TREE;
12516     }
12517
12518   fn = NULL_TREE;
12519   /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12520      mem{cpy,pcpy,move,set} is available.  */
12521   switch (fcode)
12522     {
12523     case BUILT_IN_MEMCPY_CHK:
12524       fn = built_in_decls[BUILT_IN_MEMCPY];
12525       break;
12526     case BUILT_IN_MEMPCPY_CHK:
12527       fn = built_in_decls[BUILT_IN_MEMPCPY];
12528       break;
12529     case BUILT_IN_MEMMOVE_CHK:
12530       fn = built_in_decls[BUILT_IN_MEMMOVE];
12531       break;
12532     case BUILT_IN_MEMSET_CHK:
12533       fn = built_in_decls[BUILT_IN_MEMSET];
12534       break;
12535     default:
12536       break;
12537     }
12538
12539   if (!fn)
12540     return NULL_TREE;
12541
12542   return build_call_expr (fn, 3, dest, src, len);
12543 }
12544
12545 /* Fold a call to the __st[rp]cpy_chk builtin.
12546    DEST, SRC, and SIZE are the arguments to the call.
12547    IGNORE is true if return value can be ignored.  FCODE is the BUILT_IN_*
12548    code of the builtin.  If MAXLEN is not NULL, it is maximum length of
12549    strings passed as second argument.  */
12550
12551 tree
12552 fold_builtin_stxcpy_chk (tree fndecl, tree dest, tree src, tree size,
12553                          tree maxlen, bool ignore,
12554                          enum built_in_function fcode)
12555 {
12556   tree len, fn;
12557
12558   if (!validate_arg (dest, POINTER_TYPE)
12559       || !validate_arg (src, POINTER_TYPE)
12560       || !validate_arg (size, INTEGER_TYPE))
12561     return NULL_TREE;
12562
12563   /* If SRC and DEST are the same (and not volatile), return DEST.  */
12564   if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12565     return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), dest);
12566
12567   if (! host_integerp (size, 1))
12568     return NULL_TREE;
12569
12570   if (! integer_all_onesp (size))
12571     {
12572       len = c_strlen (src, 1);
12573       if (! len || ! host_integerp (len, 1))
12574         {
12575           /* If LEN is not constant, try MAXLEN too.
12576              For MAXLEN only allow optimizing into non-_ocs function
12577              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12578           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12579             {
12580               if (fcode == BUILT_IN_STPCPY_CHK)
12581                 {
12582                   if (! ignore)
12583                     return NULL_TREE;
12584
12585                   /* If return value of __stpcpy_chk is ignored,
12586                      optimize into __strcpy_chk.  */
12587                   fn = built_in_decls[BUILT_IN_STRCPY_CHK];
12588                   if (!fn)
12589                     return NULL_TREE;
12590
12591                   return build_call_expr (fn, 3, dest, src, size);
12592                 }
12593
12594               if (! len || TREE_SIDE_EFFECTS (len))
12595                 return NULL_TREE;
12596
12597               /* If c_strlen returned something, but not a constant,
12598                  transform __strcpy_chk into __memcpy_chk.  */
12599               fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12600               if (!fn)
12601                 return NULL_TREE;
12602
12603               len = size_binop (PLUS_EXPR, len, ssize_int (1));
12604               return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)),
12605                                    build_call_expr (fn, 4,
12606                                                     dest, src, len, size));
12607             }
12608         }
12609       else
12610         maxlen = len;
12611
12612       if (! tree_int_cst_lt (maxlen, size))
12613         return NULL_TREE;
12614     }
12615
12616   /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available.  */
12617   fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
12618                       ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
12619   if (!fn)
12620     return NULL_TREE;
12621
12622   return build_call_expr (fn, 2, dest, src);
12623 }
12624
12625 /* Fold a call to the __strncpy_chk builtin.  DEST, SRC, LEN, and SIZE
12626    are the arguments to the call.  If MAXLEN is not NULL, it is maximum
12627    length passed as third argument.  */
12628
12629 tree
12630 fold_builtin_strncpy_chk (tree dest, tree src, tree len, tree size,
12631                           tree maxlen)
12632 {
12633   tree fn;
12634
12635   if (!validate_arg (dest, POINTER_TYPE)
12636       || !validate_arg (src, POINTER_TYPE)
12637       || !validate_arg (len, INTEGER_TYPE)
12638       || !validate_arg (size, INTEGER_TYPE))
12639     return NULL_TREE;
12640
12641   if (! host_integerp (size, 1))
12642     return NULL_TREE;
12643
12644   if (! integer_all_onesp (size))
12645     {
12646       if (! host_integerp (len, 1))
12647         {
12648           /* If LEN is not constant, try MAXLEN too.
12649              For MAXLEN only allow optimizing into non-_ocs function
12650              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12651           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12652             return NULL_TREE;
12653         }
12654       else
12655         maxlen = len;
12656
12657       if (tree_int_cst_lt (size, maxlen))
12658         return NULL_TREE;
12659     }
12660
12661   /* If __builtin_strncpy_chk is used, assume strncpy is available.  */
12662   fn = built_in_decls[BUILT_IN_STRNCPY];
12663   if (!fn)
12664     return NULL_TREE;
12665
12666   return build_call_expr (fn, 3, dest, src, len);
12667 }
12668
12669 /* Fold a call to the __strcat_chk builtin FNDECL.  DEST, SRC, and SIZE
12670    are the arguments to the call.  */
12671
12672 static tree
12673 fold_builtin_strcat_chk (tree fndecl, tree dest, tree src, tree size)
12674 {
12675   tree fn;
12676   const char *p;
12677
12678   if (!validate_arg (dest, POINTER_TYPE)
12679       || !validate_arg (src, POINTER_TYPE)
12680       || !validate_arg (size, INTEGER_TYPE))
12681     return NULL_TREE;
12682
12683   p = c_getstr (src);
12684   /* If the SRC parameter is "", return DEST.  */
12685   if (p && *p == '\0')
12686     return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12687
12688   if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12689     return NULL_TREE;
12690
12691   /* If __builtin_strcat_chk is used, assume strcat is available.  */
12692   fn = built_in_decls[BUILT_IN_STRCAT];
12693   if (!fn)
12694     return NULL_TREE;
12695
12696   return build_call_expr (fn, 2, dest, src);
12697 }
12698
12699 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12700    LEN, and SIZE.  */
12701
12702 static tree
12703 fold_builtin_strncat_chk (tree fndecl,
12704                           tree dest, tree src, tree len, tree size)
12705 {
12706   tree fn;
12707   const char *p;
12708
12709   if (!validate_arg (dest, POINTER_TYPE)
12710       || !validate_arg (src, POINTER_TYPE)
12711       || !validate_arg (size, INTEGER_TYPE)
12712       || !validate_arg (size, INTEGER_TYPE))
12713     return NULL_TREE;
12714
12715   p = c_getstr (src);
12716   /* If the SRC parameter is "" or if LEN is 0, return DEST.  */
12717   if (p && *p == '\0')
12718     return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12719   else if (integer_zerop (len))
12720     return omit_one_operand (TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12721
12722   if (! host_integerp (size, 1))
12723     return NULL_TREE;
12724
12725   if (! integer_all_onesp (size))
12726     {
12727       tree src_len = c_strlen (src, 1);
12728       if (src_len
12729           && host_integerp (src_len, 1)
12730           && host_integerp (len, 1)
12731           && ! tree_int_cst_lt (len, src_len))
12732         {
12733           /* If LEN >= strlen (SRC), optimize into __strcat_chk.  */
12734           fn = built_in_decls[BUILT_IN_STRCAT_CHK];
12735           if (!fn)
12736             return NULL_TREE;
12737
12738           return build_call_expr (fn, 3, dest, src, size);
12739         }
12740       return NULL_TREE;
12741     }
12742
12743   /* If __builtin_strncat_chk is used, assume strncat is available.  */
12744   fn = built_in_decls[BUILT_IN_STRNCAT];
12745   if (!fn)
12746     return NULL_TREE;
12747
12748   return build_call_expr (fn, 3, dest, src, len);
12749 }
12750
12751 /* Fold a call EXP to __{,v}sprintf_chk.  Return NULL_TREE if
12752    a normal call should be emitted rather than expanding the function
12753    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
12754
12755 static tree
12756 fold_builtin_sprintf_chk (tree exp, enum built_in_function fcode)
12757 {
12758   tree dest, size, len, fn, fmt, flag;
12759   const char *fmt_str;
12760   int nargs = call_expr_nargs (exp);
12761
12762   /* Verify the required arguments in the original call.  */
12763   if (nargs < 4)
12764     return NULL_TREE;
12765   dest = CALL_EXPR_ARG (exp, 0);
12766   if (!validate_arg (dest, POINTER_TYPE))
12767     return NULL_TREE;
12768   flag = CALL_EXPR_ARG (exp, 1);
12769   if (!validate_arg (flag, INTEGER_TYPE))
12770     return NULL_TREE;
12771   size = CALL_EXPR_ARG (exp, 2);
12772   if (!validate_arg (size, INTEGER_TYPE))
12773     return NULL_TREE;
12774   fmt = CALL_EXPR_ARG (exp, 3);
12775   if (!validate_arg (fmt, POINTER_TYPE))
12776     return NULL_TREE;
12777
12778   if (! host_integerp (size, 1))
12779     return NULL_TREE;
12780
12781   len = NULL_TREE;
12782
12783   if (!init_target_chars ())
12784     return NULL_TREE;
12785
12786   /* Check whether the format is a literal string constant.  */
12787   fmt_str = c_getstr (fmt);
12788   if (fmt_str != NULL)
12789     {
12790       /* If the format doesn't contain % args or %%, we know the size.  */
12791       if (strchr (fmt_str, target_percent) == 0)
12792         {
12793           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
12794             len = build_int_cstu (size_type_node, strlen (fmt_str));
12795         }
12796       /* If the format is "%s" and first ... argument is a string literal,
12797          we know the size too.  */
12798       else if (fcode == BUILT_IN_SPRINTF_CHK
12799                && strcmp (fmt_str, target_percent_s) == 0)
12800         {
12801           tree arg;
12802
12803           if (nargs == 5)
12804             {
12805               arg = CALL_EXPR_ARG (exp, 4);
12806               if (validate_arg (arg, POINTER_TYPE))
12807                 {
12808                   len = c_strlen (arg, 1);
12809                   if (! len || ! host_integerp (len, 1))
12810                     len = NULL_TREE;
12811                 }
12812             }
12813         }
12814     }
12815
12816   if (! integer_all_onesp (size))
12817     {
12818       if (! len || ! tree_int_cst_lt (len, size))
12819         return NULL_TREE;
12820     }
12821
12822   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12823      or if format doesn't contain % chars or is "%s".  */
12824   if (! integer_zerop (flag))
12825     {
12826       if (fmt_str == NULL)
12827         return NULL_TREE;
12828       if (strchr (fmt_str, target_percent) != NULL
12829           && strcmp (fmt_str, target_percent_s))
12830         return NULL_TREE;
12831     }
12832
12833   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
12834   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
12835                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
12836   if (!fn)
12837     return NULL_TREE;
12838
12839   return rewrite_call_expr (exp, 4, fn, 2, dest, fmt);
12840 }
12841
12842 /* Fold a call EXP to {,v}snprintf.  Return NULL_TREE if
12843    a normal call should be emitted rather than expanding the function
12844    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
12845    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
12846    passed as second argument.  */
12847
12848 tree
12849 fold_builtin_snprintf_chk (tree exp, tree maxlen,
12850                            enum built_in_function fcode)
12851 {
12852   tree dest, size, len, fn, fmt, flag;
12853   const char *fmt_str;
12854
12855   /* Verify the required arguments in the original call.  */
12856   if (call_expr_nargs (exp) < 5)
12857     return NULL_TREE;
12858   dest = CALL_EXPR_ARG (exp, 0);
12859   if (!validate_arg (dest, POINTER_TYPE))
12860     return NULL_TREE;
12861   len = CALL_EXPR_ARG (exp, 1);
12862   if (!validate_arg (len, INTEGER_TYPE))
12863     return NULL_TREE;
12864   flag = CALL_EXPR_ARG (exp, 2);
12865   if (!validate_arg (flag, INTEGER_TYPE))
12866     return NULL_TREE;
12867   size = CALL_EXPR_ARG (exp, 3);
12868   if (!validate_arg (size, INTEGER_TYPE))
12869     return NULL_TREE;
12870   fmt = CALL_EXPR_ARG (exp, 4);
12871   if (!validate_arg (fmt, POINTER_TYPE))
12872     return NULL_TREE;
12873
12874   if (! host_integerp (size, 1))
12875     return NULL_TREE;
12876
12877   if (! integer_all_onesp (size))
12878     {
12879       if (! host_integerp (len, 1))
12880         {
12881           /* If LEN is not constant, try MAXLEN too.
12882              For MAXLEN only allow optimizing into non-_ocs function
12883              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12884           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12885             return NULL_TREE;
12886         }
12887       else
12888         maxlen = len;
12889
12890       if (tree_int_cst_lt (size, maxlen))
12891         return NULL_TREE;
12892     }
12893
12894   if (!init_target_chars ())
12895     return NULL_TREE;
12896
12897   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12898      or if format doesn't contain % chars or is "%s".  */
12899   if (! integer_zerop (flag))
12900     {
12901       fmt_str = c_getstr (fmt);
12902       if (fmt_str == NULL)
12903         return NULL_TREE;
12904       if (strchr (fmt_str, target_percent) != NULL
12905           && strcmp (fmt_str, target_percent_s))
12906         return NULL_TREE;
12907     }
12908
12909   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12910      available.  */
12911   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
12912                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
12913   if (!fn)
12914     return NULL_TREE;
12915
12916   return rewrite_call_expr (exp, 5, fn, 3, dest, len, fmt);
12917 }
12918
12919 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12920    FMT and ARG are the arguments to the call; we don't fold cases with
12921    more than 2 arguments, and ARG may be null if this is a 1-argument case.
12922
12923    Return NULL_TREE if no simplification was possible, otherwise return the
12924    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12925    code of the function to be simplified.  */
12926
12927 static tree
12928 fold_builtin_printf (tree fndecl, tree fmt, tree arg, bool ignore,
12929                      enum built_in_function fcode)
12930 {
12931   tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
12932   const char *fmt_str = NULL;
12933
12934   /* If the return value is used, don't do the transformation.  */
12935   if (! ignore)
12936     return NULL_TREE;
12937
12938   /* Verify the required arguments in the original call.  */
12939   if (!validate_arg (fmt, POINTER_TYPE))
12940     return NULL_TREE;
12941
12942   /* Check whether the format is a literal string constant.  */
12943   fmt_str = c_getstr (fmt);
12944   if (fmt_str == NULL)
12945     return NULL_TREE;
12946
12947   if (fcode == BUILT_IN_PRINTF_UNLOCKED)
12948     {
12949       /* If we're using an unlocked function, assume the other
12950          unlocked functions exist explicitly.  */
12951       fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
12952       fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
12953     }
12954   else
12955     {
12956       fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
12957       fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
12958     }
12959
12960   if (!init_target_chars ())
12961     return NULL_TREE;
12962
12963   if (strcmp (fmt_str, target_percent_s) == 0
12964       || strchr (fmt_str, target_percent) == NULL)
12965     {
12966       const char *str;
12967
12968       if (strcmp (fmt_str, target_percent_s) == 0)
12969         {
12970           if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12971             return NULL_TREE;
12972
12973           if (!arg || !validate_arg (arg, POINTER_TYPE))
12974             return NULL_TREE;
12975
12976           str = c_getstr (arg);
12977           if (str == NULL)
12978             return NULL_TREE;
12979         }
12980       else
12981         {
12982           /* The format specifier doesn't contain any '%' characters.  */
12983           if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
12984               && arg)
12985             return NULL_TREE;
12986           str = fmt_str;
12987         }
12988
12989       /* If the string was "", printf does nothing.  */
12990       if (str[0] == '\0')
12991         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12992
12993       /* If the string has length of 1, call putchar.  */
12994       if (str[1] == '\0')
12995         {
12996           /* Given printf("c"), (where c is any one character,)
12997              convert "c"[0] to an int and pass that to the replacement
12998              function.  */
12999           newarg = build_int_cst (NULL_TREE, str[0]);
13000           if (fn_putchar)
13001             call = build_call_expr (fn_putchar, 1, newarg);
13002         }
13003       else
13004         {
13005           /* If the string was "string\n", call puts("string").  */
13006           size_t len = strlen (str);
13007           if ((unsigned char)str[len - 1] == target_newline)
13008             {
13009               /* Create a NUL-terminated string that's one char shorter
13010                  than the original, stripping off the trailing '\n'.  */
13011               char *newstr = XALLOCAVEC (char, len);
13012               memcpy (newstr, str, len - 1);
13013               newstr[len - 1] = 0;
13014
13015               newarg = build_string_literal (len, newstr);
13016               if (fn_puts)
13017                 call = build_call_expr (fn_puts, 1, newarg);
13018             }
13019           else
13020             /* We'd like to arrange to call fputs(string,stdout) here,
13021                but we need stdout and don't have a way to get it yet.  */
13022             return NULL_TREE;
13023         }
13024     }
13025
13026   /* The other optimizations can be done only on the non-va_list variants.  */
13027   else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
13028     return NULL_TREE;
13029
13030   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
13031   else if (strcmp (fmt_str, target_percent_s_newline) == 0)
13032     {
13033       if (!arg || !validate_arg (arg, POINTER_TYPE))
13034         return NULL_TREE;
13035       if (fn_puts)
13036         call = build_call_expr (fn_puts, 1, arg);
13037     }
13038
13039   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
13040   else if (strcmp (fmt_str, target_percent_c) == 0)
13041     {
13042       if (!arg || !validate_arg (arg, INTEGER_TYPE))
13043         return NULL_TREE;
13044       if (fn_putchar)
13045         call = build_call_expr (fn_putchar, 1, arg);
13046     }
13047
13048   if (!call)
13049     return NULL_TREE;
13050
13051   return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
13052 }
13053
13054 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
13055    FP, FMT, and ARG are the arguments to the call.  We don't fold calls with
13056    more than 3 arguments, and ARG may be null in the 2-argument case.
13057
13058    Return NULL_TREE if no simplification was possible, otherwise return the
13059    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
13060    code of the function to be simplified.  */
13061
13062 static tree
13063 fold_builtin_fprintf (tree fndecl, tree fp, tree fmt, tree arg, bool ignore,
13064                       enum built_in_function fcode)
13065 {
13066   tree fn_fputc, fn_fputs, call = NULL_TREE;
13067   const char *fmt_str = NULL;
13068
13069   /* If the return value is used, don't do the transformation.  */
13070   if (! ignore)
13071     return NULL_TREE;
13072
13073   /* Verify the required arguments in the original call.  */
13074   if (!validate_arg (fp, POINTER_TYPE))
13075     return NULL_TREE;
13076   if (!validate_arg (fmt, POINTER_TYPE))
13077     return NULL_TREE;
13078
13079   /* Check whether the format is a literal string constant.  */
13080   fmt_str = c_getstr (fmt);
13081   if (fmt_str == NULL)
13082     return NULL_TREE;
13083
13084   if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
13085     {
13086       /* If we're using an unlocked function, assume the other
13087          unlocked functions exist explicitly.  */
13088       fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
13089       fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
13090     }
13091   else
13092     {
13093       fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
13094       fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
13095     }
13096
13097   if (!init_target_chars ())
13098     return NULL_TREE;
13099
13100   /* If the format doesn't contain % args or %%, use strcpy.  */
13101   if (strchr (fmt_str, target_percent) == NULL)
13102     {
13103       if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
13104           && arg)
13105         return NULL_TREE;
13106
13107       /* If the format specifier was "", fprintf does nothing.  */
13108       if (fmt_str[0] == '\0')
13109         {
13110           /* If FP has side-effects, just wait until gimplification is
13111              done.  */
13112           if (TREE_SIDE_EFFECTS (fp))
13113             return NULL_TREE;
13114
13115           return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
13116         }
13117
13118       /* When "string" doesn't contain %, replace all cases of
13119          fprintf (fp, string) with fputs (string, fp).  The fputs
13120          builtin will take care of special cases like length == 1.  */
13121       if (fn_fputs)
13122         call = build_call_expr (fn_fputs, 2, fmt, fp);
13123     }
13124
13125   /* The other optimizations can be done only on the non-va_list variants.  */
13126   else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
13127     return NULL_TREE;
13128
13129   /* If the format specifier was "%s", call __builtin_fputs (arg, fp).  */
13130   else if (strcmp (fmt_str, target_percent_s) == 0)
13131     {
13132       if (!arg || !validate_arg (arg, POINTER_TYPE))
13133         return NULL_TREE;
13134       if (fn_fputs)
13135         call = build_call_expr (fn_fputs, 2, arg, fp);
13136     }
13137
13138   /* If the format specifier was "%c", call __builtin_fputc (arg, fp).  */
13139   else if (strcmp (fmt_str, target_percent_c) == 0)
13140     {
13141       if (!arg || !validate_arg (arg, INTEGER_TYPE))
13142         return NULL_TREE;
13143       if (fn_fputc)
13144         call = build_call_expr (fn_fputc, 2, arg, fp);
13145     }
13146
13147   if (!call)
13148     return NULL_TREE;
13149   return fold_convert (TREE_TYPE (TREE_TYPE (fndecl)), call);
13150 }
13151
13152 /* Initialize format string characters in the target charset.  */
13153
13154 static bool
13155 init_target_chars (void)
13156 {
13157   static bool init;
13158   if (!init)
13159     {
13160       target_newline = lang_hooks.to_target_charset ('\n');
13161       target_percent = lang_hooks.to_target_charset ('%');
13162       target_c = lang_hooks.to_target_charset ('c');
13163       target_s = lang_hooks.to_target_charset ('s');
13164       if (target_newline == 0 || target_percent == 0 || target_c == 0
13165           || target_s == 0)
13166         return false;
13167
13168       target_percent_c[0] = target_percent;
13169       target_percent_c[1] = target_c;
13170       target_percent_c[2] = '\0';
13171
13172       target_percent_s[0] = target_percent;
13173       target_percent_s[1] = target_s;
13174       target_percent_s[2] = '\0';
13175
13176       target_percent_s_newline[0] = target_percent;
13177       target_percent_s_newline[1] = target_s;
13178       target_percent_s_newline[2] = target_newline;
13179       target_percent_s_newline[3] = '\0';
13180
13181       init = true;
13182     }
13183   return true;
13184 }
13185
13186 /* Helper function for do_mpfr_arg*().  Ensure M is a normal number
13187    and no overflow/underflow occurred.  INEXACT is true if M was not
13188    exactly calculated.  TYPE is the tree type for the result.  This
13189    function assumes that you cleared the MPFR flags and then
13190    calculated M to see if anything subsequently set a flag prior to
13191    entering this function.  Return NULL_TREE if any checks fail.  */
13192
13193 static tree
13194 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
13195 {
13196   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13197      overflow/underflow occurred.  If -frounding-math, proceed iff the
13198      result of calling FUNC was exact.  */
13199   if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
13200       && (!flag_rounding_math || !inexact))
13201     {
13202       REAL_VALUE_TYPE rr;
13203
13204       real_from_mpfr (&rr, m, type, GMP_RNDN);
13205       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
13206          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
13207          but the mpft_t is not, then we underflowed in the
13208          conversion.  */
13209       if (real_isfinite (&rr)
13210           && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
13211         {
13212           REAL_VALUE_TYPE rmode;
13213
13214           real_convert (&rmode, TYPE_MODE (type), &rr);
13215           /* Proceed iff the specified mode can hold the value.  */
13216           if (real_identical (&rmode, &rr))
13217             return build_real (type, rmode);
13218         }
13219     }
13220   return NULL_TREE;
13221 }
13222
13223 #ifdef HAVE_mpc
13224 /* Helper function for do_mpc_arg*().  Ensure M is a normal complex
13225    number and no overflow/underflow occurred.  INEXACT is true if M
13226    was not exactly calculated.  TYPE is the tree type for the result.
13227    This function assumes that you cleared the MPFR flags and then
13228    calculated M to see if anything subsequently set a flag prior to
13229    entering this function.  Return NULL_TREE if any checks fail.  */
13230
13231 static tree
13232 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact)
13233 {
13234   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13235      overflow/underflow occurred.  If -frounding-math, proceed iff the
13236      result of calling FUNC was exact.  */
13237   if (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
13238       && !mpfr_overflow_p () && !mpfr_underflow_p ()
13239       && (!flag_rounding_math || !inexact))
13240     {
13241       REAL_VALUE_TYPE re, im;
13242
13243       real_from_mpfr (&re, mpc_realref (m), type, GMP_RNDN);
13244       real_from_mpfr (&im, mpc_imagref (m), type, GMP_RNDN);
13245       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
13246          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
13247          but the mpft_t is not, then we underflowed in the
13248          conversion.  */
13249       if (real_isfinite (&re) && real_isfinite (&im)
13250           && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
13251           && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0))
13252         {
13253           REAL_VALUE_TYPE re_mode, im_mode;
13254
13255           real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
13256           real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
13257           /* Proceed iff the specified mode can hold the value.  */
13258           if (real_identical (&re_mode, &re) && real_identical (&im_mode, &im))
13259             return build_complex (type, build_real (TREE_TYPE (type), re_mode),
13260                                   build_real (TREE_TYPE (type), im_mode));
13261         }
13262     }
13263   return NULL_TREE;
13264 }
13265 #endif /* HAVE_mpc */
13266
13267 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
13268    FUNC on it and return the resulting value as a tree with type TYPE.
13269    If MIN and/or MAX are not NULL, then the supplied ARG must be
13270    within those bounds.  If INCLUSIVE is true, then MIN/MAX are
13271    acceptable values, otherwise they are not.  The mpfr precision is
13272    set to the precision of TYPE.  We assume that function FUNC returns
13273    zero if the result could be calculated exactly within the requested
13274    precision.  */
13275
13276 static tree
13277 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
13278               const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
13279               bool inclusive)
13280 {
13281   tree result = NULL_TREE;
13282
13283   STRIP_NOPS (arg);
13284
13285   /* To proceed, MPFR must exactly represent the target floating point
13286      format, which only happens when the target base equals two.  */
13287   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13288       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13289     {
13290       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13291
13292       if (real_isfinite (ra)
13293           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13294           && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13295         {
13296           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13297           const int prec = fmt->p;
13298           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13299           int inexact;
13300           mpfr_t m;
13301
13302           mpfr_init2 (m, prec);
13303           mpfr_from_real (m, ra, GMP_RNDN);
13304           mpfr_clear_flags ();
13305           inexact = func (m, m, rnd);
13306           result = do_mpfr_ckconv (m, type, inexact);
13307           mpfr_clear (m);
13308         }
13309     }
13310
13311   return result;
13312 }
13313
13314 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13315    FUNC on it and return the resulting value as a tree with type TYPE.
13316    The mpfr precision is set to the precision of TYPE.  We assume that
13317    function FUNC returns zero if the result could be calculated
13318    exactly within the requested precision.  */
13319
13320 static tree
13321 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13322               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13323 {
13324   tree result = NULL_TREE;
13325
13326   STRIP_NOPS (arg1);
13327   STRIP_NOPS (arg2);
13328
13329   /* To proceed, MPFR must exactly represent the target floating point
13330      format, which only happens when the target base equals two.  */
13331   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13332       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13333       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13334     {
13335       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13336       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13337
13338       if (real_isfinite (ra1) && real_isfinite (ra2))
13339         {
13340           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13341           const int prec = fmt->p;
13342           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13343           int inexact;
13344           mpfr_t m1, m2;
13345
13346           mpfr_inits2 (prec, m1, m2, NULL);
13347           mpfr_from_real (m1, ra1, GMP_RNDN);
13348           mpfr_from_real (m2, ra2, GMP_RNDN);
13349           mpfr_clear_flags ();
13350           inexact = func (m1, m1, m2, rnd);
13351           result = do_mpfr_ckconv (m1, type, inexact);
13352           mpfr_clears (m1, m2, NULL);
13353         }
13354     }
13355
13356   return result;
13357 }
13358
13359 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13360    FUNC on it and return the resulting value as a tree with type TYPE.
13361    The mpfr precision is set to the precision of TYPE.  We assume that
13362    function FUNC returns zero if the result could be calculated
13363    exactly within the requested precision.  */
13364
13365 static tree
13366 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13367               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13368 {
13369   tree result = NULL_TREE;
13370
13371   STRIP_NOPS (arg1);
13372   STRIP_NOPS (arg2);
13373   STRIP_NOPS (arg3);
13374
13375   /* To proceed, MPFR must exactly represent the target floating point
13376      format, which only happens when the target base equals two.  */
13377   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13378       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13379       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13380       && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13381     {
13382       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13383       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13384       const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13385
13386       if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13387         {
13388           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13389           const int prec = fmt->p;
13390           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13391           int inexact;
13392           mpfr_t m1, m2, m3;
13393
13394           mpfr_inits2 (prec, m1, m2, m3, NULL);
13395           mpfr_from_real (m1, ra1, GMP_RNDN);
13396           mpfr_from_real (m2, ra2, GMP_RNDN);
13397           mpfr_from_real (m3, ra3, GMP_RNDN);
13398           mpfr_clear_flags ();
13399           inexact = func (m1, m1, m2, m3, rnd);
13400           result = do_mpfr_ckconv (m1, type, inexact);
13401           mpfr_clears (m1, m2, m3, NULL);
13402         }
13403     }
13404
13405   return result;
13406 }
13407
13408 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13409    the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13410    If ARG_SINP and ARG_COSP are NULL then the result is returned
13411    as a complex value.
13412    The type is taken from the type of ARG and is used for setting the
13413    precision of the calculation and results.  */
13414
13415 static tree
13416 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13417 {
13418   tree const type = TREE_TYPE (arg);
13419   tree result = NULL_TREE;
13420
13421   STRIP_NOPS (arg);
13422
13423   /* To proceed, MPFR must exactly represent the target floating point
13424      format, which only happens when the target base equals two.  */
13425   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13426       && TREE_CODE (arg) == REAL_CST
13427       && !TREE_OVERFLOW (arg))
13428     {
13429       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13430
13431       if (real_isfinite (ra))
13432         {
13433           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13434           const int prec = fmt->p;
13435           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13436           tree result_s, result_c;
13437           int inexact;
13438           mpfr_t m, ms, mc;
13439
13440           mpfr_inits2 (prec, m, ms, mc, NULL);
13441           mpfr_from_real (m, ra, GMP_RNDN);
13442           mpfr_clear_flags ();
13443           inexact = mpfr_sin_cos (ms, mc, m, rnd);
13444           result_s = do_mpfr_ckconv (ms, type, inexact);
13445           result_c = do_mpfr_ckconv (mc, type, inexact);
13446           mpfr_clears (m, ms, mc, NULL);
13447           if (result_s && result_c)
13448             {
13449               /* If we are to return in a complex value do so.  */
13450               if (!arg_sinp && !arg_cosp)
13451                 return build_complex (build_complex_type (type),
13452                                       result_c, result_s);
13453
13454               /* Dereference the sin/cos pointer arguments.  */
13455               arg_sinp = build_fold_indirect_ref (arg_sinp);
13456               arg_cosp = build_fold_indirect_ref (arg_cosp);
13457               /* Proceed if valid pointer type were passed in.  */
13458               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13459                   && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13460                 {
13461                   /* Set the values. */
13462                   result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13463                                           result_s);
13464                   TREE_SIDE_EFFECTS (result_s) = 1;
13465                   result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13466                                           result_c);
13467                   TREE_SIDE_EFFECTS (result_c) = 1;
13468                   /* Combine the assignments into a compound expr.  */
13469                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13470                                                     result_s, result_c));
13471                 }
13472             }
13473         }
13474     }
13475   return result;
13476 }
13477
13478 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13479    two-argument mpfr order N Bessel function FUNC on them and return
13480    the resulting value as a tree with type TYPE.  The mpfr precision
13481    is set to the precision of TYPE.  We assume that function FUNC
13482    returns zero if the result could be calculated exactly within the
13483    requested precision.  */
13484 static tree
13485 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13486                   int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13487                   const REAL_VALUE_TYPE *min, bool inclusive)
13488 {
13489   tree result = NULL_TREE;
13490
13491   STRIP_NOPS (arg1);
13492   STRIP_NOPS (arg2);
13493
13494   /* To proceed, MPFR must exactly represent the target floating point
13495      format, which only happens when the target base equals two.  */
13496   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13497       && host_integerp (arg1, 0)
13498       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13499     {
13500       const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13501       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13502
13503       if (n == (long)n
13504           && real_isfinite (ra)
13505           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13506         {
13507           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13508           const int prec = fmt->p;
13509           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13510           int inexact;
13511           mpfr_t m;
13512
13513           mpfr_init2 (m, prec);
13514           mpfr_from_real (m, ra, GMP_RNDN);
13515           mpfr_clear_flags ();
13516           inexact = func (m, n, m, rnd);
13517           result = do_mpfr_ckconv (m, type, inexact);
13518           mpfr_clear (m);
13519         }
13520     }
13521
13522   return result;
13523 }
13524
13525 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13526    the pointer *(ARG_QUO) and return the result.  The type is taken
13527    from the type of ARG0 and is used for setting the precision of the
13528    calculation and results.  */
13529
13530 static tree
13531 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13532 {
13533   tree const type = TREE_TYPE (arg0);
13534   tree result = NULL_TREE;
13535
13536   STRIP_NOPS (arg0);
13537   STRIP_NOPS (arg1);
13538
13539   /* To proceed, MPFR must exactly represent the target floating point
13540      format, which only happens when the target base equals two.  */
13541   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13542       && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13543       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13544     {
13545       const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13546       const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13547
13548       if (real_isfinite (ra0) && real_isfinite (ra1))
13549         {
13550           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13551           const int prec = fmt->p;
13552           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13553           tree result_rem;
13554           long integer_quo;
13555           mpfr_t m0, m1;
13556
13557           mpfr_inits2 (prec, m0, m1, NULL);
13558           mpfr_from_real (m0, ra0, GMP_RNDN);
13559           mpfr_from_real (m1, ra1, GMP_RNDN);
13560           mpfr_clear_flags ();
13561           mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13562           /* Remquo is independent of the rounding mode, so pass
13563              inexact=0 to do_mpfr_ckconv().  */
13564           result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13565           mpfr_clears (m0, m1, NULL);
13566           if (result_rem)
13567             {
13568               /* MPFR calculates quo in the host's long so it may
13569                  return more bits in quo than the target int can hold
13570                  if sizeof(host long) > sizeof(target int).  This can
13571                  happen even for native compilers in LP64 mode.  In
13572                  these cases, modulo the quo value with the largest
13573                  number that the target int can hold while leaving one
13574                  bit for the sign.  */
13575               if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13576                 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13577
13578               /* Dereference the quo pointer argument.  */
13579               arg_quo = build_fold_indirect_ref (arg_quo);
13580               /* Proceed iff a valid pointer type was passed in.  */
13581               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13582                 {
13583                   /* Set the value. */
13584                   tree result_quo = fold_build2 (MODIFY_EXPR,
13585                                                  TREE_TYPE (arg_quo), arg_quo,
13586                                                  build_int_cst (NULL, integer_quo));
13587                   TREE_SIDE_EFFECTS (result_quo) = 1;
13588                   /* Combine the quo assignment with the rem.  */
13589                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13590                                                     result_quo, result_rem));
13591                 }
13592             }
13593         }
13594     }
13595   return result;
13596 }
13597
13598 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13599    resulting value as a tree with type TYPE.  The mpfr precision is
13600    set to the precision of TYPE.  We assume that this mpfr function
13601    returns zero if the result could be calculated exactly within the
13602    requested precision.  In addition, the integer pointer represented
13603    by ARG_SG will be dereferenced and set to the appropriate signgam
13604    (-1,1) value.  */
13605
13606 static tree
13607 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13608 {
13609   tree result = NULL_TREE;
13610
13611   STRIP_NOPS (arg);
13612
13613   /* To proceed, MPFR must exactly represent the target floating point
13614      format, which only happens when the target base equals two.  Also
13615      verify ARG is a constant and that ARG_SG is an int pointer.  */
13616   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13617       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13618       && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13619       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13620     {
13621       const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13622
13623       /* In addition to NaN and Inf, the argument cannot be zero or a
13624          negative integer.  */
13625       if (real_isfinite (ra)
13626           && ra->cl != rvc_zero
13627           && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13628         {
13629           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13630           const int prec = fmt->p;
13631           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13632           int inexact, sg;
13633           mpfr_t m;
13634           tree result_lg;
13635
13636           mpfr_init2 (m, prec);
13637           mpfr_from_real (m, ra, GMP_RNDN);
13638           mpfr_clear_flags ();
13639           inexact = mpfr_lgamma (m, &sg, m, rnd);
13640           result_lg = do_mpfr_ckconv (m, type, inexact);
13641           mpfr_clear (m);
13642           if (result_lg)
13643             {
13644               tree result_sg;
13645
13646               /* Dereference the arg_sg pointer argument.  */
13647               arg_sg = build_fold_indirect_ref (arg_sg);
13648               /* Assign the signgam value into *arg_sg. */
13649               result_sg = fold_build2 (MODIFY_EXPR,
13650                                        TREE_TYPE (arg_sg), arg_sg,
13651                                        build_int_cst (NULL, sg));
13652               TREE_SIDE_EFFECTS (result_sg) = 1;
13653               /* Combine the signgam assignment with the lgamma result.  */
13654               result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13655                                                 result_sg, result_lg));
13656             }
13657         }
13658     }
13659
13660   return result;
13661 }
13662
13663 #ifdef HAVE_mpc
13664 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13665    function FUNC on it and return the resulting value as a tree with
13666    type TYPE.  The mpfr precision is set to the precision of TYPE.  We
13667    assume that function FUNC returns zero if the result could be
13668    calculated exactly within the requested precision.  */
13669
13670 static tree
13671 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13672 {
13673   tree result = NULL_TREE;
13674
13675   STRIP_NOPS (arg);
13676
13677   /* To proceed, MPFR must exactly represent the target floating point
13678      format, which only happens when the target base equals two.  */
13679   if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
13680       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
13681       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
13682     {
13683       const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
13684       const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
13685
13686       if (real_isfinite (re) && real_isfinite (im))
13687         {
13688           const struct real_format *const fmt =
13689             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13690           const int prec = fmt->p;
13691           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13692           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13693           int inexact;
13694           mpc_t m;
13695
13696           mpc_init2 (m, prec);
13697           mpfr_from_real (mpc_realref(m), re, rnd);
13698           mpfr_from_real (mpc_imagref(m), im, rnd);
13699           mpfr_clear_flags ();
13700           inexact = func (m, m, crnd);
13701           result = do_mpc_ckconv (m, type, inexact);
13702           mpc_clear (m);
13703         }
13704     }
13705
13706   return result;
13707 }
13708 #endif /* HAVE_mpc */
13709
13710 /* FIXME tuples.
13711    The functions below provide an alternate interface for folding
13712    builtin function calls presented as GIMPLE_CALL statements rather
13713    than as CALL_EXPRs.  The folded result is still expressed as a
13714    tree.  There is too much code duplication in the handling of
13715    varargs functions, and a more intrusive re-factoring would permit
13716    better sharing of code between the tree and statement-based
13717    versions of these functions.  */
13718
13719 /* Construct a new CALL_EXPR using the tail of the argument list of STMT
13720    along with N new arguments specified as the "..." parameters.  SKIP
13721    is the number of arguments in STMT to be omitted.  This function is used
13722    to do varargs-to-varargs transformations.  */
13723
13724 static tree
13725 gimple_rewrite_call_expr (gimple stmt, int skip, tree fndecl, int n, ...)
13726 {
13727   int oldnargs = gimple_call_num_args (stmt);
13728   int nargs = oldnargs - skip + n;
13729   tree fntype = TREE_TYPE (fndecl);
13730   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
13731   tree *buffer;
13732   int i, j;
13733   va_list ap;
13734
13735   buffer = XALLOCAVEC (tree, nargs);
13736   va_start (ap, n);
13737   for (i = 0; i < n; i++)
13738     buffer[i] = va_arg (ap, tree);
13739   va_end (ap);
13740   for (j = skip; j < oldnargs; j++, i++)
13741     buffer[i] = gimple_call_arg (stmt, j);
13742
13743   return fold (build_call_array (TREE_TYPE (fntype), fn, nargs, buffer));
13744 }
13745
13746 /* Fold a call STMT to __{,v}sprintf_chk.  Return NULL_TREE if
13747    a normal call should be emitted rather than expanding the function
13748    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
13749
13750 static tree
13751 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
13752 {
13753   tree dest, size, len, fn, fmt, flag;
13754   const char *fmt_str;
13755   int nargs = gimple_call_num_args (stmt);
13756
13757   /* Verify the required arguments in the original call.  */
13758   if (nargs < 4)
13759     return NULL_TREE;
13760   dest = gimple_call_arg (stmt, 0);
13761   if (!validate_arg (dest, POINTER_TYPE))
13762     return NULL_TREE;
13763   flag = gimple_call_arg (stmt, 1);
13764   if (!validate_arg (flag, INTEGER_TYPE))
13765     return NULL_TREE;
13766   size = gimple_call_arg (stmt, 2);
13767   if (!validate_arg (size, INTEGER_TYPE))
13768     return NULL_TREE;
13769   fmt = gimple_call_arg (stmt, 3);
13770   if (!validate_arg (fmt, POINTER_TYPE))
13771     return NULL_TREE;
13772
13773   if (! host_integerp (size, 1))
13774     return NULL_TREE;
13775
13776   len = NULL_TREE;
13777
13778   if (!init_target_chars ())
13779     return NULL_TREE;
13780
13781   /* Check whether the format is a literal string constant.  */
13782   fmt_str = c_getstr (fmt);
13783   if (fmt_str != NULL)
13784     {
13785       /* If the format doesn't contain % args or %%, we know the size.  */
13786       if (strchr (fmt_str, target_percent) == 0)
13787         {
13788           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
13789             len = build_int_cstu (size_type_node, strlen (fmt_str));
13790         }
13791       /* If the format is "%s" and first ... argument is a string literal,
13792          we know the size too.  */
13793       else if (fcode == BUILT_IN_SPRINTF_CHK
13794                && strcmp (fmt_str, target_percent_s) == 0)
13795         {
13796           tree arg;
13797
13798           if (nargs == 5)
13799             {
13800               arg = gimple_call_arg (stmt, 4);
13801               if (validate_arg (arg, POINTER_TYPE))
13802                 {
13803                   len = c_strlen (arg, 1);
13804                   if (! len || ! host_integerp (len, 1))
13805                     len = NULL_TREE;
13806                 }
13807             }
13808         }
13809     }
13810
13811   if (! integer_all_onesp (size))
13812     {
13813       if (! len || ! tree_int_cst_lt (len, size))
13814         return NULL_TREE;
13815     }
13816
13817   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13818      or if format doesn't contain % chars or is "%s".  */
13819   if (! integer_zerop (flag))
13820     {
13821       if (fmt_str == NULL)
13822         return NULL_TREE;
13823       if (strchr (fmt_str, target_percent) != NULL
13824           && strcmp (fmt_str, target_percent_s))
13825         return NULL_TREE;
13826     }
13827
13828   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
13829   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
13830                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
13831   if (!fn)
13832     return NULL_TREE;
13833
13834   return gimple_rewrite_call_expr (stmt, 4, fn, 2, dest, fmt);
13835 }
13836
13837 /* Fold a call STMT to {,v}snprintf.  Return NULL_TREE if
13838    a normal call should be emitted rather than expanding the function
13839    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
13840    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
13841    passed as second argument.  */
13842
13843 tree
13844 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
13845                                   enum built_in_function fcode)
13846 {
13847   tree dest, size, len, fn, fmt, flag;
13848   const char *fmt_str;
13849
13850   /* Verify the required arguments in the original call.  */
13851   if (gimple_call_num_args (stmt) < 5)
13852     return NULL_TREE;
13853   dest = gimple_call_arg (stmt, 0);
13854   if (!validate_arg (dest, POINTER_TYPE))
13855     return NULL_TREE;
13856   len = gimple_call_arg (stmt, 1);
13857   if (!validate_arg (len, INTEGER_TYPE))
13858     return NULL_TREE;
13859   flag = gimple_call_arg (stmt, 2);
13860   if (!validate_arg (flag, INTEGER_TYPE))
13861     return NULL_TREE;
13862   size = gimple_call_arg (stmt, 3);
13863   if (!validate_arg (size, INTEGER_TYPE))
13864     return NULL_TREE;
13865   fmt = gimple_call_arg (stmt, 4);
13866   if (!validate_arg (fmt, POINTER_TYPE))
13867     return NULL_TREE;
13868
13869   if (! host_integerp (size, 1))
13870     return NULL_TREE;
13871
13872   if (! integer_all_onesp (size))
13873     {
13874       if (! host_integerp (len, 1))
13875         {
13876           /* If LEN is not constant, try MAXLEN too.
13877              For MAXLEN only allow optimizing into non-_ocs function
13878              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
13879           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
13880             return NULL_TREE;
13881         }
13882       else
13883         maxlen = len;
13884
13885       if (tree_int_cst_lt (size, maxlen))
13886         return NULL_TREE;
13887     }
13888
13889   if (!init_target_chars ())
13890     return NULL_TREE;
13891
13892   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13893      or if format doesn't contain % chars or is "%s".  */
13894   if (! integer_zerop (flag))
13895     {
13896       fmt_str = c_getstr (fmt);
13897       if (fmt_str == NULL)
13898         return NULL_TREE;
13899       if (strchr (fmt_str, target_percent) != NULL
13900           && strcmp (fmt_str, target_percent_s))
13901         return NULL_TREE;
13902     }
13903
13904   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13905      available.  */
13906   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
13907                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
13908   if (!fn)
13909     return NULL_TREE;
13910
13911   return gimple_rewrite_call_expr (stmt, 5, fn, 3, dest, len, fmt);
13912 }
13913
13914 /* Builtins with folding operations that operate on "..." arguments
13915    need special handling; we need to store the arguments in a convenient
13916    data structure before attempting any folding.  Fortunately there are
13917    only a few builtins that fall into this category.  FNDECL is the
13918    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13919    result of the function call is ignored.  */
13920
13921 static tree
13922 gimple_fold_builtin_varargs (tree fndecl, gimple stmt, bool ignore ATTRIBUTE_UNUSED)
13923 {
13924   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13925   tree ret = NULL_TREE;
13926
13927   switch (fcode)
13928     {
13929     case BUILT_IN_SPRINTF_CHK:
13930     case BUILT_IN_VSPRINTF_CHK:
13931       ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
13932       break;
13933
13934     case BUILT_IN_SNPRINTF_CHK:
13935     case BUILT_IN_VSNPRINTF_CHK:
13936       ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
13937
13938     default:
13939       break;
13940     }
13941   if (ret)
13942     {
13943       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
13944       TREE_NO_WARNING (ret) = 1;
13945       return ret;
13946     }
13947   return NULL_TREE;
13948 }
13949
13950 /* A wrapper function for builtin folding that prevents warnings for
13951    "statement without effect" and the like, caused by removing the
13952    call node earlier than the warning is generated.  */
13953
13954 tree
13955 fold_call_stmt (gimple stmt, bool ignore)
13956 {
13957   tree ret = NULL_TREE;
13958   tree fndecl = gimple_call_fndecl (stmt);
13959   if (fndecl
13960       && TREE_CODE (fndecl) == FUNCTION_DECL
13961       && DECL_BUILT_IN (fndecl)
13962       && !gimple_call_va_arg_pack_p (stmt))
13963     {
13964       int nargs = gimple_call_num_args (stmt);
13965
13966       if (avoid_folding_inline_builtin (fndecl))
13967         return NULL_TREE;
13968       /* FIXME: Don't use a list in this interface.  */
13969       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
13970         {
13971           tree arglist = NULL_TREE;
13972           int i;
13973           for (i = nargs - 1; i >= 0; i--)
13974             arglist = tree_cons (NULL_TREE, gimple_call_arg (stmt, i), arglist);
13975           return targetm.fold_builtin (fndecl, arglist, ignore);
13976         }
13977       else
13978         {
13979           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
13980             {
13981               tree args[MAX_ARGS_TO_FOLD_BUILTIN];
13982               int i;
13983               for (i = 0; i < nargs; i++)
13984                 args[i] = gimple_call_arg (stmt, i);
13985               ret = fold_builtin_n (fndecl, args, nargs, ignore);
13986             }
13987           if (!ret)
13988             ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
13989           if (ret)
13990             {
13991               /* Propagate location information from original call to
13992                  expansion of builtin.  Otherwise things like
13993                  maybe_emit_chk_warning, that operate on the expansion
13994                  of a builtin, will use the wrong location information.  */
13995               if (gimple_has_location (stmt))
13996                 {
13997                   tree realret = ret;
13998                   if (TREE_CODE (ret) == NOP_EXPR)
13999                     realret = TREE_OPERAND (ret, 0);
14000                   if (CAN_HAVE_LOCATION_P (realret)
14001                       && !EXPR_HAS_LOCATION (realret))
14002                     SET_EXPR_LOCATION (realret, gimple_location (stmt));
14003                   return realret;
14004                 }
14005               return ret;
14006             }
14007         }
14008     }
14009   return NULL_TREE;
14010 }