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_memcmp (tree, rtx, enum machine_mode);
 116 static rtx expand_builtin_strcmp (tree, rtx);
 117 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
 118 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 119 static rtx expand_builtin_memcpy (tree, rtx);
 120 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
 121 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
 122                                         enum machine_mode, int);
 123 static rtx expand_builtin_strcpy (tree, rtx);
 124 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
 125 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
 126 static rtx expand_builtin_strncpy (tree, rtx);
 127 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
 128 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
 129 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
 130 static rtx expand_builtin_bzero (tree);
 131 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
 132 static rtx expand_builtin_alloca (tree, rtx);
 133 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
 134 static rtx expand_builtin_frame_address (tree, tree);
 135 static rtx expand_builtin_printf (tree, rtx, enum machine_mode, bool);
 136 static rtx expand_builtin_fprintf (tree, rtx, enum machine_mode, bool);
 137 static rtx expand_builtin_sprintf (tree, rtx, enum machine_mode);
 138 static tree stabilize_va_list_loc (location_t, tree, int);
 139 static rtx expand_builtin_expect (tree, rtx);
 140 static tree fold_builtin_constant_p (tree);
 141 static tree fold_builtin_expect (location_t, tree, tree);
 142 static tree fold_builtin_classify_type (tree);
 143 static tree fold_builtin_strlen (location_t, tree);
 144 static tree fold_builtin_inf (location_t, tree, int);
 145 static tree fold_builtin_nan (tree, tree, int);
 146 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
 147 static bool validate_arg (const_tree, enum tree_code code);
 148 static bool integer_valued_real_p (tree);
 149 static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
 150 static bool readonly_data_expr (tree);
 151 static rtx expand_builtin_fabs (tree, rtx, rtx);
 152 static rtx expand_builtin_signbit (tree, rtx);
 153 static tree fold_builtin_sqrt (location_t, tree, tree);
 154 static tree fold_builtin_cbrt (location_t, tree, tree);
 155 static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
 156 static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
 157 static tree fold_builtin_cos (location_t, tree, tree, tree);
 158 static tree fold_builtin_cosh (location_t, tree, tree, tree);
 159 static tree fold_builtin_tan (tree, tree);
 160 static tree fold_builtin_trunc (location_t, tree, tree);
 161 static tree fold_builtin_floor (location_t, tree, tree);
 162 static tree fold_builtin_ceil (location_t, tree, tree);
 163 static tree fold_builtin_round (location_t, tree, tree);
 164 static tree fold_builtin_int_roundingfn (location_t, tree, tree);
 165 static tree fold_builtin_bitop (tree, tree);
 166 static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
 167 static tree fold_builtin_strchr (location_t, tree, tree, tree);
 168 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
 169 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
 170 static tree fold_builtin_strcmp (location_t, tree, tree);
 171 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
 172 static tree fold_builtin_signbit (location_t, tree, tree);
 173 static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
 174 static tree fold_builtin_isascii (location_t, tree);
 175 static tree fold_builtin_toascii (location_t, tree);
 176 static tree fold_builtin_isdigit (location_t, tree);
 177 static tree fold_builtin_fabs (location_t, tree, tree);
 178 static tree fold_builtin_abs (location_t, tree, tree);
 179 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
 180                                         enum tree_code);
 181 static tree fold_builtin_n (location_t, tree, tree *, int, bool);
 182 static tree fold_builtin_0 (location_t, tree, bool);
 183 static tree fold_builtin_1 (location_t, tree, tree, bool);
 184 static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
 185 static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
 186 static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
 187 static tree fold_builtin_varargs (location_t, tree, tree, bool);
 188
 189 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
 190 static tree fold_builtin_strstr (location_t, tree, tree, tree);
 191 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
 192 static tree fold_builtin_strcat (location_t, tree, tree);
 193 static tree fold_builtin_strncat (location_t, tree, tree, tree);
 194 static tree fold_builtin_strspn (location_t, tree, tree);
 195 static tree fold_builtin_strcspn (location_t, tree, tree);
 196 static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
 197
 198 static rtx expand_builtin_object_size (tree);
 199 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
 200                                       enum built_in_function);
 201 static void maybe_emit_chk_warning (tree, enum built_in_function);
 202 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 203 static void maybe_emit_free_warning (tree);
 204 static tree fold_builtin_object_size (tree, tree);
 205 static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
 206 static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
 207 static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
 208 static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
 209 static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
 210                                   enum built_in_function);
 211 static bool init_target_chars (void);
 212
 213 static unsigned HOST_WIDE_INT target_newline;
 214 static unsigned HOST_WIDE_INT target_percent;
 215 static unsigned HOST_WIDE_INT target_c;
 216 static unsigned HOST_WIDE_INT target_s;
 217 static char target_percent_c[3];
 218 static char target_percent_s[3];
 219 static char target_percent_s_newline[4];
 220 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
 221                           const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
 222 static tree do_mpfr_arg2 (tree, tree, tree,
 223                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 224 static tree do_mpfr_arg3 (tree, tree, tree, tree,
 225                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 226 static tree do_mpfr_sincos (tree, tree, tree);
 227 static tree do_mpfr_bessel_n (tree, tree, tree,
 228                               int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
 229                               const REAL_VALUE_TYPE *, bool);
 230 static tree do_mpfr_remquo (tree, tree, tree);
 231 static tree do_mpfr_lgamma_r (tree, tree, tree);
 232
 233 /* Return true if NAME starts with __builtin_ or __sync_.  */
 234
 235 bool
 236 is_builtin_name (const char *name)
 237 {
 238   if (strncmp (name, "__builtin_", 10) == 0)
 239     return true;
 240   if (strncmp (name, "__sync_", 7) == 0)
 241     return true;
 242   return false;
 243 }
 244
 245
 246 /* Return true if DECL is a function symbol representing a built-in.  */
 247
 248 bool
 249 is_builtin_fn (tree decl)
 250 {
 251   return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
 252 }
 253
 254
 255 /* Return true if NODE should be considered for inline expansion regardless
 256    of the optimization level.  This means whenever a function is invoked with
 257    its "internal" name, which normally contains the prefix "__builtin".  */
 258
 259 static bool
 260 called_as_built_in (tree node)
 261 {
 262   /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
 263      we want the name used to call the function, not the name it
 264      will have. */
 265   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 266   return is_builtin_name (name);
 267 }
 268
 269 /* Return the alignment in bits of EXP, an object.
 270    Don't return more than MAX_ALIGN no matter what, ALIGN is the inital
 271    guessed alignment e.g. from type alignment.  */
 272
 273 int
 274 get_object_alignment (tree exp, unsigned int align, unsigned int max_align)
 275 {
 276   unsigned int inner;
 277
 278   inner = max_align;
 279   if (handled_component_p (exp))
 280    {
 281       HOST_WIDE_INT bitsize, bitpos;
 282       tree offset;
 283       enum machine_mode mode;
 284       int unsignedp, volatilep;
 285
 286       exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
 287                                  &mode, &unsignedp, &volatilep, true);
 288       if (bitpos)
 289         inner = MIN (inner, (unsigned) (bitpos & -bitpos));
 290       while (offset)
 291         {
 292           tree next_offset;
 293
 294           if (TREE_CODE (offset) == PLUS_EXPR)
 295             {
 296               next_offset = TREE_OPERAND (offset, 0);
 297               offset = TREE_OPERAND (offset, 1);
 298             }
 299           else
 300             next_offset = NULL;
 301           if (host_integerp (offset, 1))
 302             {
 303               /* Any overflow in calculating offset_bits won't change
 304                  the alignment.  */
 305               unsigned offset_bits
 306                 = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
 307
 308               if (offset_bits)
 309                 inner = MIN (inner, (offset_bits & -offset_bits));
 310             }
 311           else if (TREE_CODE (offset) == MULT_EXPR
 312                    && host_integerp (TREE_OPERAND (offset, 1), 1))
 313             {
 314               /* Any overflow in calculating offset_factor won't change
 315                  the alignment.  */
 316               unsigned offset_factor
 317                 = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
 318                    * BITS_PER_UNIT);
 319
 320               if (offset_factor)
 321                 inner = MIN (inner, (offset_factor & -offset_factor));
 322             }
 323           else
 324             {
 325               inner = MIN (inner, BITS_PER_UNIT);
 326               break;
 327             }
 328           offset = next_offset;
 329         }
 330     }
 331   if (DECL_P (exp))
 332     align = MIN (inner, DECL_ALIGN (exp));
 333 #ifdef CONSTANT_ALIGNMENT
 334   else if (CONSTANT_CLASS_P (exp))
 335     align = MIN (inner, (unsigned)CONSTANT_ALIGNMENT (exp, align));
 336 #endif
 337   else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR
 338            || TREE_CODE (exp) == INDIRECT_REF)
 339     align = MIN (TYPE_ALIGN (TREE_TYPE (exp)), inner);
 340   else
 341     align = MIN (align, inner);
 342   return MIN (align, max_align);
 343 }
 344
 345 /* Returns true iff we can trust that alignment information has been
 346    calculated properly.  */
 347
 348 bool
 349 can_trust_pointer_alignment (void)
 350 {
 351   /* We rely on TER to compute accurate alignment information.  */
 352   return (optimize && flag_tree_ter);
 353 }
 354
 355 /* Return the alignment in bits of EXP, a pointer valued expression.
 356    But don't return more than MAX_ALIGN no matter what.
 357    The alignment returned is, by default, the alignment of the thing that
 358    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 359
 360    Otherwise, look at the expression to see if we can do better, i.e., if the
 361    expression is actually pointing at an object whose alignment is tighter.  */
 362
 363 int
 364 get_pointer_alignment (tree exp, unsigned int max_align)
 365 {
 366   unsigned int align, inner;
 367
 368   if (!can_trust_pointer_alignment ())
 369     return 0;
 370
 371   if (!POINTER_TYPE_P (TREE_TYPE (exp)))
 372     return 0;
 373
 374   align = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
 375   align = MIN (align, max_align);
 376
 377   while (1)
 378     {
 379       switch (TREE_CODE (exp))
 380         {
 381         CASE_CONVERT:
 382           exp = TREE_OPERAND (exp, 0);
 383           if (! POINTER_TYPE_P (TREE_TYPE (exp)))
 384             return align;
 385
 386           inner = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp)));
 387           align = MIN (inner, max_align);
 388           break;
 389
 390         case POINTER_PLUS_EXPR:
 391           /* If sum of pointer + int, restrict our maximum alignment to that
 392              imposed by the integer.  If not, we can't do any better than
 393              ALIGN.  */
 394           if (! host_integerp (TREE_OPERAND (exp, 1), 1))
 395             return align;
 396
 397           while (((tree_low_cst (TREE_OPERAND (exp, 1), 1))
 398                   & (max_align / BITS_PER_UNIT - 1))
 399                  != 0)
 400             max_align >>= 1;
 401
 402           exp = TREE_OPERAND (exp, 0);
 403           break;
 404
 405         case ADDR_EXPR:
 406           /* See what we are pointing at and look at its alignment.  */
 407           return get_object_alignment (TREE_OPERAND (exp, 0), align, max_align);
 408
 409         default:
 410           return align;
 411         }
 412     }
 413 }
 414
 415 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 416    way, because it could contain a zero byte in the middle.
 417    TREE_STRING_LENGTH is the size of the character array, not the string.
 418
 419    ONLY_VALUE should be nonzero if the result is not going to be emitted
 420    into the instruction stream and zero if it is going to be expanded.
 421    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 422    is returned, otherwise NULL, since
 423    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
 424    evaluate the side-effects.
 425
 426    The value returned is of type `ssizetype'.
 427
 428    Unfortunately, string_constant can't access the values of const char
 429    arrays with initializers, so neither can we do so here.  */
 430
 431 tree
 432 c_strlen (tree src, int only_value)
 433 {
 434   tree offset_node;
 435   HOST_WIDE_INT offset;
 436   int max;
 437   const char *ptr;
 438
 439   STRIP_NOPS (src);
 440   if (TREE_CODE (src) == COND_EXPR
 441       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 442     {
 443       tree len1, len2;
 444
 445       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
 446       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
 447       if (tree_int_cst_equal (len1, len2))
 448         return len1;
 449     }
 450
 451   if (TREE_CODE (src) == COMPOUND_EXPR
 452       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 453     return c_strlen (TREE_OPERAND (src, 1), only_value);
 454
 455   src = string_constant (src, &offset_node);
 456   if (src == 0)
 457     return NULL_TREE;
 458
 459   max = TREE_STRING_LENGTH (src) - 1;
 460   ptr = TREE_STRING_POINTER (src);
 461
 462   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 463     {
 464       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 465          compute the offset to the following null if we don't know where to
 466          start searching for it.  */
 467       int i;
 468
 469       for (i = 0; i < max; i++)
 470         if (ptr[i] == 0)
 471           return NULL_TREE;
 472
 473       /* We don't know the starting offset, but we do know that the string
 474          has no internal zero bytes.  We can assume that the offset falls
 475          within the bounds of the string; otherwise, the programmer deserves
 476          what he gets.  Subtract the offset from the length of the string,
 477          and return that.  This would perhaps not be valid if we were dealing
 478          with named arrays in addition to literal string constants.  */
 479
 480       return size_diffop_loc (input_location, size_int (max), offset_node);
 481     }
 482
 483   /* We have a known offset into the string.  Start searching there for
 484      a null character if we can represent it as a single HOST_WIDE_INT.  */
 485   if (offset_node == 0)
 486     offset = 0;
 487   else if (! host_integerp (offset_node, 0))
 488     offset = -1;
 489   else
 490     offset = tree_low_cst (offset_node, 0);
 491
 492   /* If the offset is known to be out of bounds, warn, and call strlen at
 493      runtime.  */
 494   if (offset < 0 || offset > max)
 495     {
 496      /* Suppress multiple warnings for propagated constant strings.  */
 497       if (! TREE_NO_WARNING (src))
 498         {
 499           warning (0, "offset outside bounds of constant string");
 500           TREE_NO_WARNING (src) = 1;
 501         }
 502       return NULL_TREE;
 503     }
 504
 505   /* Use strlen to search for the first zero byte.  Since any strings
 506      constructed with build_string will have nulls appended, we win even
 507      if we get handed something like (char[4])"abcd".
 508
 509      Since OFFSET is our starting index into the string, no further
 510      calculation is needed.  */
 511   return ssize_int (strlen (ptr + offset));
 512 }
 513
 514 /* Return a char pointer for a C string if it is a string constant
 515    or sum of string constant and integer constant.  */
 516
 517 static const char *
 518 c_getstr (tree src)
 519 {
 520   tree offset_node;
 521
 522   src = string_constant (src, &offset_node);
 523   if (src == 0)
 524     return 0;
 525
 526   if (offset_node == 0)
 527     return TREE_STRING_POINTER (src);
 528   else if (!host_integerp (offset_node, 1)
 529            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
 530     return 0;
 531
 532   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
 533 }
 534
 535 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
 536    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 537
 538 static rtx
 539 c_readstr (const char *str, enum machine_mode mode)
 540 {
 541   HOST_WIDE_INT c[2];
 542   HOST_WIDE_INT ch;
 543   unsigned int i, j;
 544
 545   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
 546
 547   c[0] = 0;
 548   c[1] = 0;
 549   ch = 1;
 550   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 551     {
 552       j = i;
 553       if (WORDS_BIG_ENDIAN)
 554         j = GET_MODE_SIZE (mode) - i - 1;
 555       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 556           && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
 557         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 558       j *= BITS_PER_UNIT;
 559       gcc_assert (j <= 2 * HOST_BITS_PER_WIDE_INT);
 560
 561       if (ch)
 562         ch = (unsigned char) str[i];
 563       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 564     }
 565   return immed_double_const (c[0], c[1], mode);
 566 }
 567
 568 /* Cast a target constant CST to target CHAR and if that value fits into
 569    host char type, return zero and put that value into variable pointed to by
 570    P.  */
 571
 572 static int
 573 target_char_cast (tree cst, char *p)
 574 {
 575   unsigned HOST_WIDE_INT val, hostval;
 576
 577   if (!host_integerp (cst, 1)
 578       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 579     return 1;
 580
 581   val = tree_low_cst (cst, 1);
 582   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 583     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 584
 585   hostval = val;
 586   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 587     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 588
 589   if (val != hostval)
 590     return 1;
 591
 592   *p = hostval;
 593   return 0;
 594 }
 595
 596 /* Similar to save_expr, but assumes that arbitrary code is not executed
 597    in between the multiple evaluations.  In particular, we assume that a
 598    non-addressable local variable will not be modified.  */
 599
 600 static tree
 601 builtin_save_expr (tree exp)
 602 {
 603   if (TREE_ADDRESSABLE (exp) == 0
 604       && (TREE_CODE (exp) == PARM_DECL
 605           || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
 606     return exp;
 607
 608   return save_expr (exp);
 609 }
 610
 611 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 612    times to get the address of either a higher stack frame, or a return
 613    address located within it (depending on FNDECL_CODE).  */
 614
 615 static rtx
 616 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
 617 {
 618   int i;
 619
 620 #ifdef INITIAL_FRAME_ADDRESS_RTX
 621   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
 622 #else
 623   rtx tem;
 624
 625   /* For a zero count with __builtin_return_address, we don't care what
 626      frame address we return, because target-specific definitions will
 627      override us.  Therefore frame pointer elimination is OK, and using
 628      the soft frame pointer is OK.
 629
 630      For a nonzero count, or a zero count with __builtin_frame_address,
 631      we require a stable offset from the current frame pointer to the
 632      previous one, so we must use the hard frame pointer, and
 633      we must disable frame pointer elimination.  */
 634   if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
 635     tem = frame_pointer_rtx;
 636   else
 637     {
 638       tem = hard_frame_pointer_rtx;
 639
 640       /* Tell reload not to eliminate the frame pointer.  */
 641       crtl->accesses_prior_frames = 1;
 642     }
 643 #endif
 644
 645   /* Some machines need special handling before we can access
 646      arbitrary frames.  For example, on the SPARC, we must first flush
 647      all register windows to the stack.  */
 648 #ifdef SETUP_FRAME_ADDRESSES
 649   if (count > 0)
 650     SETUP_FRAME_ADDRESSES ();
 651 #endif
 652
 653   /* On the SPARC, the return address is not in the frame, it is in a
 654      register.  There is no way to access it off of the current frame
 655      pointer, but it can be accessed off the previous frame pointer by
 656      reading the value from the register window save area.  */
 657 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
 658   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
 659     count--;
 660 #endif
 661
 662   /* Scan back COUNT frames to the specified frame.  */
 663   for (i = 0; i < count; i++)
 664     {
 665       /* Assume the dynamic chain pointer is in the word that the
 666          frame address points to, unless otherwise specified.  */
 667 #ifdef DYNAMIC_CHAIN_ADDRESS
 668       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 669 #endif
 670       tem = memory_address (Pmode, tem);
 671       tem = gen_frame_mem (Pmode, tem);
 672       tem = copy_to_reg (tem);
 673     }
 674
 675   /* For __builtin_frame_address, return what we've got.  But, on
 676      the SPARC for example, we may have to add a bias.  */
 677   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 678 #ifdef FRAME_ADDR_RTX
 679     return FRAME_ADDR_RTX (tem);
 680 #else
 681     return tem;
 682 #endif
 683
 684   /* For __builtin_return_address, get the return address from that frame.  */
 685 #ifdef RETURN_ADDR_RTX
 686   tem = RETURN_ADDR_RTX (count, tem);
 687 #else
 688   tem = memory_address (Pmode,
 689                         plus_constant (tem, GET_MODE_SIZE (Pmode)));
 690   tem = gen_frame_mem (Pmode, tem);
 691 #endif
 692   return tem;
 693 }
 694
 695 /* Alias set used for setjmp buffer.  */
 696 static alias_set_type setjmp_alias_set = -1;
 697
 698 /* Construct the leading half of a __builtin_setjmp call.  Control will
 699    return to RECEIVER_LABEL.  This is also called directly by the SJLJ
 700    exception handling code.  */
 701
 702 void
 703 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 704 {
 705   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 706   rtx stack_save;
 707   rtx mem;
 708
 709   if (setjmp_alias_set == -1)
 710     setjmp_alias_set = new_alias_set ();
 711
 712   buf_addr = convert_memory_address (Pmode, buf_addr);
 713
 714   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 715
 716   /* We store the frame pointer and the address of receiver_label in
 717      the buffer and use the rest of it for the stack save area, which
 718      is machine-dependent.  */
 719
 720   mem = gen_rtx_MEM (Pmode, buf_addr);
 721   set_mem_alias_set (mem, setjmp_alias_set);
 722   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
 723
 724   mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
 725   set_mem_alias_set (mem, setjmp_alias_set);
 726
 727   emit_move_insn (validize_mem (mem),
 728                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 729
 730   stack_save = gen_rtx_MEM (sa_mode,
 731                             plus_constant (buf_addr,
 732                                            2 * GET_MODE_SIZE (Pmode)));
 733   set_mem_alias_set (stack_save, setjmp_alias_set);
 734   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
 735
 736   /* If there is further processing to do, do it.  */
 737 #ifdef HAVE_builtin_setjmp_setup
 738   if (HAVE_builtin_setjmp_setup)
 739     emit_insn (gen_builtin_setjmp_setup (buf_addr));
 740 #endif
 741
 742   /* Tell optimize_save_area_alloca that extra work is going to
 743      need to go on during alloca.  */
 744   cfun->calls_setjmp = 1;
 745
 746   /* We have a nonlocal label.   */
 747   cfun->has_nonlocal_label = 1;
 748 }
 749
 750 /* Construct the trailing part of a __builtin_setjmp call.  This is
 751    also called directly by the SJLJ exception handling code.  */
 752
 753 void
 754 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
 755 {
 756   rtx chain;
 757
 758   /* Clobber the FP when we get here, so we have to make sure it's
 759      marked as used by this function.  */
 760   emit_use (hard_frame_pointer_rtx);
 761
 762   /* Mark the static chain as clobbered here so life information
 763      doesn't get messed up for it.  */
 764   chain = targetm.calls.static_chain (current_function_decl, true);
 765   if (chain && REG_P (chain))
 766     emit_clobber (chain);
 767
 768   /* Now put in the code to restore the frame pointer, and argument
 769      pointer, if needed.  */
 770 #ifdef HAVE_nonlocal_goto
 771   if (! HAVE_nonlocal_goto)
 772 #endif
 773     {
 774       emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 775       /* This might change the hard frame pointer in ways that aren't
 776          apparent to early optimization passes, so force a clobber.  */
 777       emit_clobber (hard_frame_pointer_rtx);
 778     }
 779
 780 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 781   if (fixed_regs[ARG_POINTER_REGNUM])
 782     {
 783 #ifdef ELIMINABLE_REGS
 784       size_t i;
 785       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 786
 787       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 788         if (elim_regs[i].from == ARG_POINTER_REGNUM
 789             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 790           break;
 791
 792       if (i == ARRAY_SIZE (elim_regs))
 793 #endif
 794         {
 795           /* Now restore our arg pointer from the address at which it
 796              was saved in our stack frame.  */
 797           emit_move_insn (crtl->args.internal_arg_pointer,
 798                           copy_to_reg (get_arg_pointer_save_area ()));
 799         }
 800     }
 801 #endif
 802
 803 #ifdef HAVE_builtin_setjmp_receiver
 804   if (HAVE_builtin_setjmp_receiver)
 805     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
 806   else
 807 #endif
 808 #ifdef HAVE_nonlocal_goto_receiver
 809     if (HAVE_nonlocal_goto_receiver)
 810       emit_insn (gen_nonlocal_goto_receiver ());
 811     else
 812 #endif
 813       { /* Nothing */ }
 814
 815   /* We must not allow the code we just generated to be reordered by
 816      scheduling.  Specifically, the update of the frame pointer must
 817      happen immediately, not later.  */
 818   emit_insn (gen_blockage ());
 819 }
 820
 821 /* __builtin_longjmp is passed a pointer to an array of five words (not
 822    all will be used on all machines).  It operates similarly to the C
 823    library function of the same name, but is more efficient.  Much of
 824    the code below is copied from the handling of non-local gotos.  */
 825
 826 static void
 827 expand_builtin_longjmp (rtx buf_addr, rtx value)
 828 {
 829   rtx fp, lab, stack, insn, last;
 830   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 831
 832   /* DRAP is needed for stack realign if longjmp is expanded to current
 833      function  */
 834   if (SUPPORTS_STACK_ALIGNMENT)
 835     crtl->need_drap = true;
 836
 837   if (setjmp_alias_set == -1)
 838     setjmp_alias_set = new_alias_set ();
 839
 840   buf_addr = convert_memory_address (Pmode, buf_addr);
 841
 842   buf_addr = force_reg (Pmode, buf_addr);
 843
 844   /* We require that the user must pass a second argument of 1, because
 845      that is what builtin_setjmp will return.  */
 846   gcc_assert (value == const1_rtx);
 847
 848   last = get_last_insn ();
 849 #ifdef HAVE_builtin_longjmp
 850   if (HAVE_builtin_longjmp)
 851     emit_insn (gen_builtin_longjmp (buf_addr));
 852   else
 853 #endif
 854     {
 855       fp = gen_rtx_MEM (Pmode, buf_addr);
 856       lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
 857                                                GET_MODE_SIZE (Pmode)));
 858
 859       stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
 860                                                    2 * GET_MODE_SIZE (Pmode)));
 861       set_mem_alias_set (fp, setjmp_alias_set);
 862       set_mem_alias_set (lab, setjmp_alias_set);
 863       set_mem_alias_set (stack, setjmp_alias_set);
 864
 865       /* Pick up FP, label, and SP from the block and jump.  This code is
 866          from expand_goto in stmt.c; see there for detailed comments.  */
 867 #ifdef HAVE_nonlocal_goto
 868       if (HAVE_nonlocal_goto)
 869         /* We have to pass a value to the nonlocal_goto pattern that will
 870            get copied into the static_chain pointer, but it does not matter
 871            what that value is, because builtin_setjmp does not use it.  */
 872         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
 873       else
 874 #endif
 875         {
 876           lab = copy_to_reg (lab);
 877
 878           emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 879           emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 880
 881           emit_move_insn (hard_frame_pointer_rtx, fp);
 882           emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
 883
 884           emit_use (hard_frame_pointer_rtx);
 885           emit_use (stack_pointer_rtx);
 886           emit_indirect_jump (lab);
 887         }
 888     }
 889
 890   /* Search backwards and mark the jump insn as a non-local goto.
 891      Note that this precludes the use of __builtin_longjmp to a
 892      __builtin_setjmp target in the same function.  However, we've
 893      already cautioned the user that these functions are for
 894      internal exception handling use only.  */
 895   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 896     {
 897       gcc_assert (insn != last);
 898
 899       if (JUMP_P (insn))
 900         {
 901           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
 902           break;
 903         }
 904       else if (CALL_P (insn))
 905         break;
 906     }
 907 }
 908
 909 /* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
 910    and the address of the save area.  */
 911
 912 static rtx
 913 expand_builtin_nonlocal_goto (tree exp)
 914 {
 915   tree t_label, t_save_area;
 916   rtx r_label, r_save_area, r_fp, r_sp, insn;
 917
 918   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
 919     return NULL_RTX;
 920
 921   t_label = CALL_EXPR_ARG (exp, 0);
 922   t_save_area = CALL_EXPR_ARG (exp, 1);
 923
 924   r_label = expand_normal (t_label);
 925   r_label = convert_memory_address (Pmode, r_label);
 926   r_save_area = expand_normal (t_save_area);
 927   r_save_area = convert_memory_address (Pmode, r_save_area);
 928   /* Copy the address of the save location to a register just in case it was based
 929     on the frame pointer.   */
 930   r_save_area = copy_to_reg (r_save_area);
 931   r_fp = gen_rtx_MEM (Pmode, r_save_area);
 932   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
 933                       plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
 934
 935   crtl->has_nonlocal_goto = 1;
 936
 937 #ifdef HAVE_nonlocal_goto
 938   /* ??? We no longer need to pass the static chain value, afaik.  */
 939   if (HAVE_nonlocal_goto)
 940     emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
 941   else
 942 #endif
 943     {
 944       r_label = copy_to_reg (r_label);
 945
 946       emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 947       emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 948
 949       /* Restore frame pointer for containing function.
 950          This sets the actual hard register used for the frame pointer
 951          to the location of the function's incoming static chain info.
 952          The non-local goto handler will then adjust it to contain the
 953          proper value and reload the argument pointer, if needed.  */
 954       emit_move_insn (hard_frame_pointer_rtx, r_fp);
 955       emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
 956
 957       /* USE of hard_frame_pointer_rtx added for consistency;
 958          not clear if really needed.  */
 959       emit_use (hard_frame_pointer_rtx);
 960       emit_use (stack_pointer_rtx);
 961
 962       /* If the architecture is using a GP register, we must
 963          conservatively assume that the target function makes use of it.
 964          The prologue of functions with nonlocal gotos must therefore
 965          initialize the GP register to the appropriate value, and we
 966          must then make sure that this value is live at the point
 967          of the jump.  (Note that this doesn't necessarily apply
 968          to targets with a nonlocal_goto pattern; they are free
 969          to implement it in their own way.  Note also that this is
 970          a no-op if the GP register is a global invariant.)  */
 971       if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
 972           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
 973         emit_use (pic_offset_table_rtx);
 974
 975       emit_indirect_jump (r_label);
 976     }
 977
 978   /* Search backwards to the jump insn and mark it as a
 979      non-local goto.  */
 980   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 981     {
 982       if (JUMP_P (insn))
 983         {
 984           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
 985           break;
 986         }
 987       else if (CALL_P (insn))
 988         break;
 989     }
 990
 991   return const0_rtx;
 992 }
 993
 994 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
 995    (not all will be used on all machines) that was passed to __builtin_setjmp.
 996    It updates the stack pointer in that block to correspond to the current
 997    stack pointer.  */
 998
 999 static void
1000 expand_builtin_update_setjmp_buf (rtx buf_addr)
1001 {
1002   enum machine_mode sa_mode = Pmode;
1003   rtx stack_save;
1004
1005
1006 #ifdef HAVE_save_stack_nonlocal
1007   if (HAVE_save_stack_nonlocal)
1008     sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
1009 #endif
1010 #ifdef STACK_SAVEAREA_MODE
1011   sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1012 #endif
1013
1014   stack_save
1015     = gen_rtx_MEM (sa_mode,
1016                    memory_address
1017                    (sa_mode,
1018                     plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1019
1020 #ifdef HAVE_setjmp
1021   if (HAVE_setjmp)
1022     emit_insn (gen_setjmp ());
1023 #endif
1024
1025   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
1026 }
1027
1028 /* Expand a call to __builtin_prefetch.  For a target that does not support
1029    data prefetch, evaluate the memory address argument in case it has side
1030    effects.  */
1031
1032 static void
1033 expand_builtin_prefetch (tree exp)
1034 {
1035   tree arg0, arg1, arg2;
1036   int nargs;
1037   rtx op0, op1, op2;
1038
1039   if (!validate_arglist (exp, POINTER_TYPE, 0))
1040     return;
1041
1042   arg0 = CALL_EXPR_ARG (exp, 0);
1043
1044   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1045      zero (read) and argument 2 (locality) defaults to 3 (high degree of
1046      locality).  */
1047   nargs = call_expr_nargs (exp);
1048   if (nargs > 1)
1049     arg1 = CALL_EXPR_ARG (exp, 1);
1050   else
1051     arg1 = integer_zero_node;
1052   if (nargs > 2)
1053     arg2 = CALL_EXPR_ARG (exp, 2);
1054   else
1055     arg2 = build_int_cst (NULL_TREE, 3);
1056
1057   /* Argument 0 is an address.  */
1058   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1059
1060   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
1061   if (TREE_CODE (arg1) != INTEGER_CST)
1062     {
1063       error ("second argument to %<__builtin_prefetch%> must be a constant");
1064       arg1 = integer_zero_node;
1065     }
1066   op1 = expand_normal (arg1);
1067   /* Argument 1 must be either zero or one.  */
1068   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1069     {
1070       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1071                " using zero");
1072       op1 = const0_rtx;
1073     }
1074
1075   /* Argument 2 (locality) must be a compile-time constant int.  */
1076   if (TREE_CODE (arg2) != INTEGER_CST)
1077     {
1078       error ("third argument to %<__builtin_prefetch%> must be a constant");
1079       arg2 = integer_zero_node;
1080     }
1081   op2 = expand_normal (arg2);
1082   /* Argument 2 must be 0, 1, 2, or 3.  */
1083   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1084     {
1085       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1086       op2 = const0_rtx;
1087     }
1088
1089 #ifdef HAVE_prefetch
1090   if (HAVE_prefetch)
1091     {
1092       if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
1093              (op0,
1094               insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1095           || (GET_MODE (op0) != Pmode))
1096         {
1097           op0 = convert_memory_address (Pmode, op0);
1098           op0 = force_reg (Pmode, op0);
1099         }
1100       emit_insn (gen_prefetch (op0, op1, op2));
1101     }
1102 #endif
1103
1104   /* Don't do anything with direct references to volatile memory, but
1105      generate code to handle other side effects.  */
1106   if (!MEM_P (op0) && side_effects_p (op0))
1107     emit_insn (op0);
1108 }
1109
1110 /* Get a MEM rtx for expression EXP which is the address of an operand
1111    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1112    the maximum length of the block of memory that might be accessed or
1113    NULL if unknown.  */
1114
1115 static rtx
1116 get_memory_rtx (tree exp, tree len)
1117 {
1118   tree orig_exp = exp;
1119   rtx addr, mem;
1120   HOST_WIDE_INT off;
1121
1122   /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1123      from its expression, for expr->a.b only <variable>.a.b is recorded.  */
1124   if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1125     exp = TREE_OPERAND (exp, 0);
1126
1127   addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1128   mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1129
1130   /* Get an expression we can use to find the attributes to assign to MEM.
1131      If it is an ADDR_EXPR, use the operand.  Otherwise, dereference it if
1132      we can.  First remove any nops.  */
1133   while (CONVERT_EXPR_P (exp)
1134          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1135     exp = TREE_OPERAND (exp, 0);
1136
1137   off = 0;
1138   if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1139       && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1140       && host_integerp (TREE_OPERAND (exp, 1), 0)
1141       && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1142     exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1143   else if (TREE_CODE (exp) == ADDR_EXPR)
1144     exp = TREE_OPERAND (exp, 0);
1145   else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1146     exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1147   else
1148     exp = NULL;
1149
1150   /* Honor attributes derived from exp, except for the alias set
1151      (as builtin stringops may alias with anything) and the size
1152      (as stringops may access multiple array elements).  */
1153   if (exp)
1154     {
1155       set_mem_attributes (mem, exp, 0);
1156
1157       if (off)
1158         mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1159
1160       /* Allow the string and memory builtins to overflow from one
1161          field into another, see http://gcc.gnu.org/PR23561.
1162          Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1163          memory accessed by the string or memory builtin will fit
1164          within the field.  */
1165       if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1166         {
1167           tree mem_expr = MEM_EXPR (mem);
1168           HOST_WIDE_INT offset = -1, length = -1;
1169           tree inner = exp;
1170
1171           while (TREE_CODE (inner) == ARRAY_REF
1172                  || CONVERT_EXPR_P (inner)
1173                  || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1174                  || TREE_CODE (inner) == SAVE_EXPR)
1175             inner = TREE_OPERAND (inner, 0);
1176
1177           gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1178
1179           if (MEM_OFFSET (mem)
1180               && CONST_INT_P (MEM_OFFSET (mem)))
1181             offset = INTVAL (MEM_OFFSET (mem));
1182
1183           if (offset >= 0 && len && host_integerp (len, 0))
1184             length = tree_low_cst (len, 0);
1185
1186           while (TREE_CODE (inner) == COMPONENT_REF)
1187             {
1188               tree field = TREE_OPERAND (inner, 1);
1189               gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1190               gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1191
1192               /* Bitfields are generally not byte-addressable.  */
1193               gcc_assert (!DECL_BIT_FIELD (field)
1194                           || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1195                                % BITS_PER_UNIT) == 0
1196                               && host_integerp (DECL_SIZE (field), 0)
1197                               && (TREE_INT_CST_LOW (DECL_SIZE (field))
1198                                   % BITS_PER_UNIT) == 0));
1199
1200               /* If we can prove that the memory starting at XEXP (mem, 0) and
1201                  ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1202                  can keep the COMPONENT_REF in MEM_EXPR.  But be careful with
1203                  fields without DECL_SIZE_UNIT like flexible array members.  */
1204               if (length >= 0
1205                   && DECL_SIZE_UNIT (field)
1206                   && host_integerp (DECL_SIZE_UNIT (field), 0))
1207                 {
1208                   HOST_WIDE_INT size
1209                     = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1210                   if (offset <= size
1211                       && length <= size
1212                       && offset + length <= size)
1213                     break;
1214                 }
1215
1216               if (offset >= 0
1217                   && host_integerp (DECL_FIELD_OFFSET (field), 0))
1218                 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1219                           + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1220                             / BITS_PER_UNIT;
1221               else
1222                 {
1223                   offset = -1;
1224                   length = -1;
1225                 }
1226
1227               mem_expr = TREE_OPERAND (mem_expr, 0);
1228               inner = TREE_OPERAND (inner, 0);
1229             }
1230
1231           if (mem_expr == NULL)
1232             offset = -1;
1233           if (mem_expr != MEM_EXPR (mem))
1234             {
1235               set_mem_expr (mem, mem_expr);
1236               set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1237             }
1238         }
1239       set_mem_alias_set (mem, 0);
1240       set_mem_size (mem, NULL_RTX);
1241     }
1242
1243   return mem;
1244 }
1245 \f
1246 /* Built-in functions to perform an untyped call and return.  */
1247
1248 /* For each register that may be used for calling a function, this
1249    gives a mode used to copy the register's value.  VOIDmode indicates
1250    the register is not used for calling a function.  If the machine
1251    has register windows, this gives only the outbound registers.
1252    INCOMING_REGNO gives the corresponding inbound register.  */
1253 static enum machine_mode apply_args_mode[FIRST_PSEUDO_REGISTER];
1254
1255 /* For each register that may be used for returning values, this gives
1256    a mode used to copy the register's value.  VOIDmode indicates the
1257    register is not used for returning values.  If the machine has
1258    register windows, this gives only the outbound registers.
1259    INCOMING_REGNO gives the corresponding inbound register.  */
1260 static enum machine_mode apply_result_mode[FIRST_PSEUDO_REGISTER];
1261
1262 /* For each register that may be used for calling a function, this
1263    gives the offset of that register into the block returned by
1264    __builtin_apply_args.  0 indicates that the register is not
1265    used for calling a function.  */
1266 static int apply_args_reg_offset[FIRST_PSEUDO_REGISTER];
1267
1268 /* Return the size required for the block returned by __builtin_apply_args,
1269    and initialize apply_args_mode.  */
1270
1271 static int
1272 apply_args_size (void)
1273 {
1274   static int size = -1;
1275   int align;
1276   unsigned int regno;
1277   enum machine_mode mode;
1278
1279   /* The values computed by this function never change.  */
1280   if (size < 0)
1281     {
1282       /* The first value is the incoming arg-pointer.  */
1283       size = GET_MODE_SIZE (Pmode);
1284
1285       /* The second value is the structure value address unless this is
1286          passed as an "invisible" first argument.  */
1287       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1288         size += GET_MODE_SIZE (Pmode);
1289
1290       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1291         if (FUNCTION_ARG_REGNO_P (regno))
1292           {
1293             mode = reg_raw_mode[regno];
1294
1295             gcc_assert (mode != VOIDmode);
1296
1297             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1298             if (size % align != 0)
1299               size = CEIL (size, align) * align;
1300             apply_args_reg_offset[regno] = size;
1301             size += GET_MODE_SIZE (mode);
1302             apply_args_mode[regno] = mode;
1303           }
1304         else
1305           {
1306             apply_args_mode[regno] = VOIDmode;
1307             apply_args_reg_offset[regno] = 0;
1308           }
1309     }
1310   return size;
1311 }
1312
1313 /* Return the size required for the block returned by __builtin_apply,
1314    and initialize apply_result_mode.  */
1315
1316 static int
1317 apply_result_size (void)
1318 {
1319   static int size = -1;
1320   int align, regno;
1321   enum machine_mode mode;
1322
1323   /* The values computed by this function never change.  */
1324   if (size < 0)
1325     {
1326       size = 0;
1327
1328       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1329         if (FUNCTION_VALUE_REGNO_P (regno))
1330           {
1331             mode = reg_raw_mode[regno];
1332
1333             gcc_assert (mode != VOIDmode);
1334
1335             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1336             if (size % align != 0)
1337               size = CEIL (size, align) * align;
1338             size += GET_MODE_SIZE (mode);
1339             apply_result_mode[regno] = mode;
1340           }
1341         else
1342           apply_result_mode[regno] = VOIDmode;
1343
1344       /* Allow targets that use untyped_call and untyped_return to override
1345          the size so that machine-specific information can be stored here.  */
1346 #ifdef APPLY_RESULT_SIZE
1347       size = APPLY_RESULT_SIZE;
1348 #endif
1349     }
1350   return size;
1351 }
1352
1353 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1354 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1355    the result block is used to save the values; otherwise it is used to
1356    restore the values.  */
1357
1358 static rtx
1359 result_vector (int savep, rtx result)
1360 {
1361   int regno, size, align, nelts;
1362   enum machine_mode mode;
1363   rtx reg, mem;
1364   rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1365
1366   size = nelts = 0;
1367   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1368     if ((mode = apply_result_mode[regno]) != VOIDmode)
1369       {
1370         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1371         if (size % align != 0)
1372           size = CEIL (size, align) * align;
1373         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1374         mem = adjust_address (result, mode, size);
1375         savevec[nelts++] = (savep
1376                             ? gen_rtx_SET (VOIDmode, mem, reg)
1377                             : gen_rtx_SET (VOIDmode, reg, mem));
1378         size += GET_MODE_SIZE (mode);
1379       }
1380   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1381 }
1382 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1383
1384 /* Save the state required to perform an untyped call with the same
1385    arguments as were passed to the current function.  */
1386
1387 static rtx
1388 expand_builtin_apply_args_1 (void)
1389 {
1390   rtx registers, tem;
1391   int size, align, regno;
1392   enum machine_mode mode;
1393   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1394
1395   /* Create a block where the arg-pointer, structure value address,
1396      and argument registers can be saved.  */
1397   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1398
1399   /* Walk past the arg-pointer and structure value address.  */
1400   size = GET_MODE_SIZE (Pmode);
1401   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1402     size += GET_MODE_SIZE (Pmode);
1403
1404   /* Save each register used in calling a function to the block.  */
1405   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1406     if ((mode = apply_args_mode[regno]) != VOIDmode)
1407       {
1408         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1409         if (size % align != 0)
1410           size = CEIL (size, align) * align;
1411
1412         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1413
1414         emit_move_insn (adjust_address (registers, mode, size), tem);
1415         size += GET_MODE_SIZE (mode);
1416       }
1417
1418   /* Save the arg pointer to the block.  */
1419   tem = copy_to_reg (crtl->args.internal_arg_pointer);
1420 #ifdef STACK_GROWS_DOWNWARD
1421   /* We need the pointer as the caller actually passed them to us, not
1422      as we might have pretended they were passed.  Make sure it's a valid
1423      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1424   tem
1425     = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1426                      NULL_RTX);
1427 #endif
1428   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1429
1430   size = GET_MODE_SIZE (Pmode);
1431
1432   /* Save the structure value address unless this is passed as an
1433      "invisible" first argument.  */
1434   if (struct_incoming_value)
1435     {
1436       emit_move_insn (adjust_address (registers, Pmode, size),
1437                       copy_to_reg (struct_incoming_value));
1438       size += GET_MODE_SIZE (Pmode);
1439     }
1440
1441   /* Return the address of the block.  */
1442   return copy_addr_to_reg (XEXP (registers, 0));
1443 }
1444
1445 /* __builtin_apply_args returns block of memory allocated on
1446    the stack into which is stored the arg pointer, structure
1447    value address, static chain, and all the registers that might
1448    possibly be used in performing a function call.  The code is
1449    moved to the start of the function so the incoming values are
1450    saved.  */
1451
1452 static rtx
1453 expand_builtin_apply_args (void)
1454 {
1455   /* Don't do __builtin_apply_args more than once in a function.
1456      Save the result of the first call and reuse it.  */
1457   if (apply_args_value != 0)
1458     return apply_args_value;
1459   {
1460     /* When this function is called, it means that registers must be
1461        saved on entry to this function.  So we migrate the
1462        call to the first insn of this function.  */
1463     rtx temp;
1464     rtx seq;
1465
1466     start_sequence ();
1467     temp = expand_builtin_apply_args_1 ();
1468     seq = get_insns ();
1469     end_sequence ();
1470
1471     apply_args_value = temp;
1472
1473     /* Put the insns after the NOTE that starts the function.
1474        If this is inside a start_sequence, make the outer-level insn
1475        chain current, so the code is placed at the start of the
1476        function.  If internal_arg_pointer is a non-virtual pseudo,
1477        it needs to be placed after the function that initializes
1478        that pseudo.  */
1479     push_topmost_sequence ();
1480     if (REG_P (crtl->args.internal_arg_pointer)
1481         && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1482       emit_insn_before (seq, parm_birth_insn);
1483     else
1484       emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1485     pop_topmost_sequence ();
1486     return temp;
1487   }
1488 }
1489
1490 /* Perform an untyped call and save the state required to perform an
1491    untyped return of whatever value was returned by the given function.  */
1492
1493 static rtx
1494 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1495 {
1496   int size, align, regno;
1497   enum machine_mode mode;
1498   rtx incoming_args, result, reg, dest, src, call_insn;
1499   rtx old_stack_level = 0;
1500   rtx call_fusage = 0;
1501   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1502
1503   arguments = convert_memory_address (Pmode, arguments);
1504
1505   /* Create a block where the return registers can be saved.  */
1506   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1507
1508   /* Fetch the arg pointer from the ARGUMENTS block.  */
1509   incoming_args = gen_reg_rtx (Pmode);
1510   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1511 #ifndef STACK_GROWS_DOWNWARD
1512   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1513                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1514 #endif
1515
1516   /* Push a new argument block and copy the arguments.  Do not allow
1517      the (potential) memcpy call below to interfere with our stack
1518      manipulations.  */
1519   do_pending_stack_adjust ();
1520   NO_DEFER_POP;
1521
1522   /* Save the stack with nonlocal if available.  */
1523 #ifdef HAVE_save_stack_nonlocal
1524   if (HAVE_save_stack_nonlocal)
1525     emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1526   else
1527 #endif
1528     emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1529
1530   /* Allocate a block of memory onto the stack and copy the memory
1531      arguments to the outgoing arguments address.  */
1532   allocate_dynamic_stack_space (argsize, 0, BITS_PER_UNIT);
1533
1534   /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1535      may have already set current_function_calls_alloca to true.
1536      current_function_calls_alloca won't be set if argsize is zero,
1537      so we have to guarantee need_drap is true here.  */
1538   if (SUPPORTS_STACK_ALIGNMENT)
1539     crtl->need_drap = true;
1540
1541   dest = virtual_outgoing_args_rtx;
1542 #ifndef STACK_GROWS_DOWNWARD
1543   if (CONST_INT_P (argsize))
1544     dest = plus_constant (dest, -INTVAL (argsize));
1545   else
1546     dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1547 #endif
1548   dest = gen_rtx_MEM (BLKmode, dest);
1549   set_mem_align (dest, PARM_BOUNDARY);
1550   src = gen_rtx_MEM (BLKmode, incoming_args);
1551   set_mem_align (src, PARM_BOUNDARY);
1552   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1553
1554   /* Refer to the argument block.  */
1555   apply_args_size ();
1556   arguments = gen_rtx_MEM (BLKmode, arguments);
1557   set_mem_align (arguments, PARM_BOUNDARY);
1558
1559   /* Walk past the arg-pointer and structure value address.  */
1560   size = GET_MODE_SIZE (Pmode);
1561   if (struct_value)
1562     size += GET_MODE_SIZE (Pmode);
1563
1564   /* Restore each of the registers previously saved.  Make USE insns
1565      for each of these registers for use in making the call.  */
1566   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1567     if ((mode = apply_args_mode[regno]) != VOIDmode)
1568       {
1569         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1570         if (size % align != 0)
1571           size = CEIL (size, align) * align;
1572         reg = gen_rtx_REG (mode, regno);
1573         emit_move_insn (reg, adjust_address (arguments, mode, size));
1574         use_reg (&call_fusage, reg);
1575         size += GET_MODE_SIZE (mode);
1576       }
1577
1578   /* Restore the structure value address unless this is passed as an
1579      "invisible" first argument.  */
1580   size = GET_MODE_SIZE (Pmode);
1581   if (struct_value)
1582     {
1583       rtx value = gen_reg_rtx (Pmode);
1584       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1585       emit_move_insn (struct_value, value);
1586       if (REG_P (struct_value))
1587         use_reg (&call_fusage, struct_value);
1588       size += GET_MODE_SIZE (Pmode);
1589     }
1590
1591   /* All arguments and registers used for the call are set up by now!  */
1592   function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1593
1594   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1595      and we don't want to load it into a register as an optimization,
1596      because prepare_call_address already did it if it should be done.  */
1597   if (GET_CODE (function) != SYMBOL_REF)
1598     function = memory_address (FUNCTION_MODE, function);
1599
1600   /* Generate the actual call instruction and save the return value.  */
1601 #ifdef HAVE_untyped_call
1602   if (HAVE_untyped_call)
1603     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1604                                       result, result_vector (1, result)));
1605   else
1606 #endif
1607 #ifdef HAVE_call_value
1608   if (HAVE_call_value)
1609     {
1610       rtx valreg = 0;
1611
1612       /* Locate the unique return register.  It is not possible to
1613          express a call that sets more than one return register using
1614          call_value; use untyped_call for that.  In fact, untyped_call
1615          only needs to save the return registers in the given block.  */
1616       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1617         if ((mode = apply_result_mode[regno]) != VOIDmode)
1618           {
1619             gcc_assert (!valreg); /* HAVE_untyped_call required.  */
1620
1621             valreg = gen_rtx_REG (mode, regno);
1622           }
1623
1624       emit_call_insn (GEN_CALL_VALUE (valreg,
1625                                       gen_rtx_MEM (FUNCTION_MODE, function),
1626                                       const0_rtx, NULL_RTX, const0_rtx));
1627
1628       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1629     }
1630   else
1631 #endif
1632     gcc_unreachable ();
1633
1634   /* Find the CALL insn we just emitted, and attach the register usage
1635      information.  */
1636   call_insn = last_call_insn ();
1637   add_function_usage_to (call_insn, call_fusage);
1638
1639   /* Restore the stack.  */
1640 #ifdef HAVE_save_stack_nonlocal
1641   if (HAVE_save_stack_nonlocal)
1642     emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1643   else
1644 #endif
1645     emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1646
1647   OK_DEFER_POP;
1648
1649   /* Return the address of the result block.  */
1650   result = copy_addr_to_reg (XEXP (result, 0));
1651   return convert_memory_address (ptr_mode, result);
1652 }
1653
1654 /* Perform an untyped return.  */
1655
1656 static void
1657 expand_builtin_return (rtx result)
1658 {
1659   int size, align, regno;
1660   enum machine_mode mode;
1661   rtx reg;
1662   rtx call_fusage = 0;
1663
1664   result = convert_memory_address (Pmode, result);
1665
1666   apply_result_size ();
1667   result = gen_rtx_MEM (BLKmode, result);
1668
1669 #ifdef HAVE_untyped_return
1670   if (HAVE_untyped_return)
1671     {
1672       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1673       emit_barrier ();
1674       return;
1675     }
1676 #endif
1677
1678   /* Restore the return value and note that each value is used.  */
1679   size = 0;
1680   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1681     if ((mode = apply_result_mode[regno]) != VOIDmode)
1682       {
1683         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1684         if (size % align != 0)
1685           size = CEIL (size, align) * align;
1686         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1687         emit_move_insn (reg, adjust_address (result, mode, size));
1688
1689         push_to_sequence (call_fusage);
1690         emit_use (reg);
1691         call_fusage = get_insns ();
1692         end_sequence ();
1693         size += GET_MODE_SIZE (mode);
1694       }
1695
1696   /* Put the USE insns before the return.  */
1697   emit_insn (call_fusage);
1698
1699   /* Return whatever values was restored by jumping directly to the end
1700      of the function.  */
1701   expand_naked_return ();
1702 }
1703
1704 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1705
1706 static enum type_class
1707 type_to_class (tree type)
1708 {
1709   switch (TREE_CODE (type))
1710     {
1711     case VOID_TYPE:        return void_type_class;
1712     case INTEGER_TYPE:     return integer_type_class;
1713     case ENUMERAL_TYPE:    return enumeral_type_class;
1714     case BOOLEAN_TYPE:     return boolean_type_class;
1715     case POINTER_TYPE:     return pointer_type_class;
1716     case REFERENCE_TYPE:   return reference_type_class;
1717     case OFFSET_TYPE:      return offset_type_class;
1718     case REAL_TYPE:        return real_type_class;
1719     case COMPLEX_TYPE:     return complex_type_class;
1720     case FUNCTION_TYPE:    return function_type_class;
1721     case METHOD_TYPE:      return method_type_class;
1722     case RECORD_TYPE:      return record_type_class;
1723     case UNION_TYPE:
1724     case QUAL_UNION_TYPE:  return union_type_class;
1725     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1726                                    ? string_type_class : array_type_class);
1727     case LANG_TYPE:        return lang_type_class;
1728     default:               return no_type_class;
1729     }
1730 }
1731
1732 /* Expand a call EXP to __builtin_classify_type.  */
1733
1734 static rtx
1735 expand_builtin_classify_type (tree exp)
1736 {
1737   if (call_expr_nargs (exp))
1738     return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1739   return GEN_INT (no_type_class);
1740 }
1741
1742 /* This helper macro, meant to be used in mathfn_built_in below,
1743    determines which among a set of three builtin math functions is
1744    appropriate for a given type mode.  The `F' and `L' cases are
1745    automatically generated from the `double' case.  */
1746 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1747   case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1748   fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1749   fcodel = BUILT_IN_MATHFN##L ; break;
1750 /* Similar to above, but appends _R after any F/L suffix.  */
1751 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1752   case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1753   fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1754   fcodel = BUILT_IN_MATHFN##L_R ; break;
1755
1756 /* Return mathematic function equivalent to FN but operating directly
1757    on TYPE, if available.  If IMPLICIT is true find the function in
1758    implicit_built_in_decls[], otherwise use built_in_decls[].  If we
1759    can't do the conversion, return zero.  */
1760
1761 static tree
1762 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit)
1763 {
1764   tree const *const fn_arr
1765     = implicit ? implicit_built_in_decls : built_in_decls;
1766   enum built_in_function fcode, fcodef, fcodel;
1767
1768   switch (fn)
1769     {
1770       CASE_MATHFN (BUILT_IN_ACOS)
1771       CASE_MATHFN (BUILT_IN_ACOSH)
1772       CASE_MATHFN (BUILT_IN_ASIN)
1773       CASE_MATHFN (BUILT_IN_ASINH)
1774       CASE_MATHFN (BUILT_IN_ATAN)
1775       CASE_MATHFN (BUILT_IN_ATAN2)
1776       CASE_MATHFN (BUILT_IN_ATANH)
1777       CASE_MATHFN (BUILT_IN_CBRT)
1778       CASE_MATHFN (BUILT_IN_CEIL)
1779       CASE_MATHFN (BUILT_IN_CEXPI)
1780       CASE_MATHFN (BUILT_IN_COPYSIGN)
1781       CASE_MATHFN (BUILT_IN_COS)
1782       CASE_MATHFN (BUILT_IN_COSH)
1783       CASE_MATHFN (BUILT_IN_DREM)
1784       CASE_MATHFN (BUILT_IN_ERF)
1785       CASE_MATHFN (BUILT_IN_ERFC)
1786       CASE_MATHFN (BUILT_IN_EXP)
1787       CASE_MATHFN (BUILT_IN_EXP10)
1788       CASE_MATHFN (BUILT_IN_EXP2)
1789       CASE_MATHFN (BUILT_IN_EXPM1)
1790       CASE_MATHFN (BUILT_IN_FABS)
1791       CASE_MATHFN (BUILT_IN_FDIM)
1792       CASE_MATHFN (BUILT_IN_FLOOR)
1793       CASE_MATHFN (BUILT_IN_FMA)
1794       CASE_MATHFN (BUILT_IN_FMAX)
1795       CASE_MATHFN (BUILT_IN_FMIN)
1796       CASE_MATHFN (BUILT_IN_FMOD)
1797       CASE_MATHFN (BUILT_IN_FREXP)
1798       CASE_MATHFN (BUILT_IN_GAMMA)
1799       CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1800       CASE_MATHFN (BUILT_IN_HUGE_VAL)
1801       CASE_MATHFN (BUILT_IN_HYPOT)
1802       CASE_MATHFN (BUILT_IN_ILOGB)
1803       CASE_MATHFN (BUILT_IN_INF)
1804       CASE_MATHFN (BUILT_IN_ISINF)
1805       CASE_MATHFN (BUILT_IN_J0)
1806       CASE_MATHFN (BUILT_IN_J1)
1807       CASE_MATHFN (BUILT_IN_JN)
1808       CASE_MATHFN (BUILT_IN_LCEIL)
1809       CASE_MATHFN (BUILT_IN_LDEXP)
1810       CASE_MATHFN (BUILT_IN_LFLOOR)
1811       CASE_MATHFN (BUILT_IN_LGAMMA)
1812       CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1813       CASE_MATHFN (BUILT_IN_LLCEIL)
1814       CASE_MATHFN (BUILT_IN_LLFLOOR)
1815       CASE_MATHFN (BUILT_IN_LLRINT)
1816       CASE_MATHFN (BUILT_IN_LLROUND)
1817       CASE_MATHFN (BUILT_IN_LOG)
1818       CASE_MATHFN (BUILT_IN_LOG10)
1819       CASE_MATHFN (BUILT_IN_LOG1P)
1820       CASE_MATHFN (BUILT_IN_LOG2)
1821       CASE_MATHFN (BUILT_IN_LOGB)
1822       CASE_MATHFN (BUILT_IN_LRINT)
1823       CASE_MATHFN (BUILT_IN_LROUND)
1824       CASE_MATHFN (BUILT_IN_MODF)
1825       CASE_MATHFN (BUILT_IN_NAN)
1826       CASE_MATHFN (BUILT_IN_NANS)
1827       CASE_MATHFN (BUILT_IN_NEARBYINT)
1828       CASE_MATHFN (BUILT_IN_NEXTAFTER)
1829       CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1830       CASE_MATHFN (BUILT_IN_POW)
1831       CASE_MATHFN (BUILT_IN_POWI)
1832       CASE_MATHFN (BUILT_IN_POW10)
1833       CASE_MATHFN (BUILT_IN_REMAINDER)
1834       CASE_MATHFN (BUILT_IN_REMQUO)
1835       CASE_MATHFN (BUILT_IN_RINT)
1836       CASE_MATHFN (BUILT_IN_ROUND)
1837       CASE_MATHFN (BUILT_IN_SCALB)
1838       CASE_MATHFN (BUILT_IN_SCALBLN)
1839       CASE_MATHFN (BUILT_IN_SCALBN)
1840       CASE_MATHFN (BUILT_IN_SIGNBIT)
1841       CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1842       CASE_MATHFN (BUILT_IN_SIN)
1843       CASE_MATHFN (BUILT_IN_SINCOS)
1844       CASE_MATHFN (BUILT_IN_SINH)
1845       CASE_MATHFN (BUILT_IN_SQRT)
1846       CASE_MATHFN (BUILT_IN_TAN)
1847       CASE_MATHFN (BUILT_IN_TANH)
1848       CASE_MATHFN (BUILT_IN_TGAMMA)
1849       CASE_MATHFN (BUILT_IN_TRUNC)
1850       CASE_MATHFN (BUILT_IN_Y0)
1851       CASE_MATHFN (BUILT_IN_Y1)
1852       CASE_MATHFN (BUILT_IN_YN)
1853
1854       default:
1855         return NULL_TREE;
1856       }
1857
1858   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1859     return fn_arr[fcode];
1860   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1861     return fn_arr[fcodef];
1862   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1863     return fn_arr[fcodel];
1864   else
1865     return NULL_TREE;
1866 }
1867
1868 /* Like mathfn_built_in_1(), but always use the implicit array.  */
1869
1870 tree
1871 mathfn_built_in (tree type, enum built_in_function fn)
1872 {
1873   return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1874 }
1875
1876 /* If errno must be maintained, expand the RTL to check if the result,
1877    TARGET, of a built-in function call, EXP, is NaN, and if so set
1878    errno to EDOM.  */
1879
1880 static void
1881 expand_errno_check (tree exp, rtx target)
1882 {
1883   rtx lab = gen_label_rtx ();
1884
1885   /* Test the result; if it is NaN, set errno=EDOM because
1886      the argument was not in the domain.  */
1887   do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1888                            NULL_RTX, NULL_RTX, lab);
1889
1890 #ifdef TARGET_EDOM
1891   /* If this built-in doesn't throw an exception, set errno directly.  */
1892   if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1893     {
1894 #ifdef GEN_ERRNO_RTX
1895       rtx errno_rtx = GEN_ERRNO_RTX;
1896 #else
1897       rtx errno_rtx
1898           = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1899 #endif
1900       emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1901       emit_label (lab);
1902       return;
1903     }
1904 #endif
1905
1906   /* Make sure the library call isn't expanded as a tail call.  */
1907   CALL_EXPR_TAILCALL (exp) = 0;
1908
1909   /* We can't set errno=EDOM directly; let the library call do it.
1910      Pop the arguments right away in case the call gets deleted.  */
1911   NO_DEFER_POP;
1912   expand_call (exp, target, 0);
1913   OK_DEFER_POP;
1914   emit_label (lab);
1915 }
1916
1917 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1918    Return NULL_RTX if a normal call should be emitted rather than expanding
1919    the function in-line.  EXP is the expression that is a call to the builtin
1920    function; if convenient, the result should be placed in TARGET.
1921    SUBTARGET may be used as the target for computing one of EXP's operands.  */
1922
1923 static rtx
1924 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1925 {
1926   optab builtin_optab;
1927   rtx op0, insns, before_call;
1928   tree fndecl = get_callee_fndecl (exp);
1929   enum machine_mode mode;
1930   bool errno_set = false;
1931   tree arg;
1932
1933   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1934     return NULL_RTX;
1935
1936   arg = CALL_EXPR_ARG (exp, 0);
1937
1938   switch (DECL_FUNCTION_CODE (fndecl))
1939     {
1940     CASE_FLT_FN (BUILT_IN_SQRT):
1941       errno_set = ! tree_expr_nonnegative_p (arg);
1942       builtin_optab = sqrt_optab;
1943       break;
1944     CASE_FLT_FN (BUILT_IN_EXP):
1945       errno_set = true; builtin_optab = exp_optab; break;
1946     CASE_FLT_FN (BUILT_IN_EXP10):
1947     CASE_FLT_FN (BUILT_IN_POW10):
1948       errno_set = true; builtin_optab = exp10_optab; break;
1949     CASE_FLT_FN (BUILT_IN_EXP2):
1950       errno_set = true; builtin_optab = exp2_optab; break;
1951     CASE_FLT_FN (BUILT_IN_EXPM1):
1952       errno_set = true; builtin_optab = expm1_optab; break;
1953     CASE_FLT_FN (BUILT_IN_LOGB):
1954       errno_set = true; builtin_optab = logb_optab; break;
1955     CASE_FLT_FN (BUILT_IN_LOG):
1956       errno_set = true; builtin_optab = log_optab; break;
1957     CASE_FLT_FN (BUILT_IN_LOG10):
1958       errno_set = true; builtin_optab = log10_optab; break;
1959     CASE_FLT_FN (BUILT_IN_LOG2):
1960       errno_set = true; builtin_optab = log2_optab; break;
1961     CASE_FLT_FN (BUILT_IN_LOG1P):
1962       errno_set = true; builtin_optab = log1p_optab; break;
1963     CASE_FLT_FN (BUILT_IN_ASIN):
1964       builtin_optab = asin_optab; break;
1965     CASE_FLT_FN (BUILT_IN_ACOS):
1966       builtin_optab = acos_optab; break;
1967     CASE_FLT_FN (BUILT_IN_TAN):
1968       builtin_optab = tan_optab; break;
1969     CASE_FLT_FN (BUILT_IN_ATAN):
1970       builtin_optab = atan_optab; break;
1971     CASE_FLT_FN (BUILT_IN_FLOOR):
1972       builtin_optab = floor_optab; break;
1973     CASE_FLT_FN (BUILT_IN_CEIL):
1974       builtin_optab = ceil_optab; break;
1975     CASE_FLT_FN (BUILT_IN_TRUNC):
1976       builtin_optab = btrunc_optab; break;
1977     CASE_FLT_FN (BUILT_IN_ROUND):
1978       builtin_optab = round_optab; break;
1979     CASE_FLT_FN (BUILT_IN_NEARBYINT):
1980       builtin_optab = nearbyint_optab;
1981       if (flag_trapping_math)
1982         break;
1983       /* Else fallthrough and expand as rint.  */
1984     CASE_FLT_FN (BUILT_IN_RINT):
1985       builtin_optab = rint_optab; break;
1986     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
1987       builtin_optab = significand_optab; break;
1988     default:
1989       gcc_unreachable ();
1990     }
1991
1992   /* Make a suitable register to place result in.  */
1993   mode = TYPE_MODE (TREE_TYPE (exp));
1994
1995   if (! flag_errno_math || ! HONOR_NANS (mode))
1996     errno_set = false;
1997
1998   /* Before working hard, check whether the instruction is available.  */
1999   if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
2000     {
2001       target = gen_reg_rtx (mode);
2002
2003       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2004          need to expand the argument again.  This way, we will not perform
2005          side-effects more the once.  */
2006       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2007
2008       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2009
2010       start_sequence ();
2011
2012       /* Compute into TARGET.
2013          Set TARGET to wherever the result comes back.  */
2014       target = expand_unop (mode, builtin_optab, op0, target, 0);
2015
2016       if (target != 0)
2017         {
2018           if (errno_set)
2019             expand_errno_check (exp, target);
2020
2021           /* Output the entire sequence.  */
2022           insns = get_insns ();
2023           end_sequence ();
2024           emit_insn (insns);
2025           return target;
2026         }
2027
2028       /* If we were unable to expand via the builtin, stop the sequence
2029          (without outputting the insns) and call to the library function
2030          with the stabilized argument list.  */
2031       end_sequence ();
2032     }
2033
2034   before_call = get_last_insn ();
2035
2036   return expand_call (exp, target, target == const0_rtx);
2037 }
2038
2039 /* Expand a call to the builtin binary math functions (pow and atan2).
2040    Return NULL_RTX if a normal call should be emitted rather than expanding the
2041    function in-line.  EXP is the expression that is a call to the builtin
2042    function; if convenient, the result should be placed in TARGET.
2043    SUBTARGET may be used as the target for computing one of EXP's
2044    operands.  */
2045
2046 static rtx
2047 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2048 {
2049   optab builtin_optab;
2050   rtx op0, op1, insns;
2051   int op1_type = REAL_TYPE;
2052   tree fndecl = get_callee_fndecl (exp);
2053   tree arg0, arg1;
2054   enum machine_mode mode;
2055   bool errno_set = true;
2056
2057   switch (DECL_FUNCTION_CODE (fndecl))
2058     {
2059     CASE_FLT_FN (BUILT_IN_SCALBN):
2060     CASE_FLT_FN (BUILT_IN_SCALBLN):
2061     CASE_FLT_FN (BUILT_IN_LDEXP):
2062       op1_type = INTEGER_TYPE;
2063     default:
2064       break;
2065     }
2066
2067   if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2068     return NULL_RTX;
2069
2070   arg0 = CALL_EXPR_ARG (exp, 0);
2071   arg1 = CALL_EXPR_ARG (exp, 1);
2072
2073   switch (DECL_FUNCTION_CODE (fndecl))
2074     {
2075     CASE_FLT_FN (BUILT_IN_POW):
2076       builtin_optab = pow_optab; break;
2077     CASE_FLT_FN (BUILT_IN_ATAN2):
2078       builtin_optab = atan2_optab; break;
2079     CASE_FLT_FN (BUILT_IN_SCALB):
2080       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2081         return 0;
2082       builtin_optab = scalb_optab; break;
2083     CASE_FLT_FN (BUILT_IN_SCALBN):
2084     CASE_FLT_FN (BUILT_IN_SCALBLN):
2085       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2086         return 0;
2087     /* Fall through... */
2088     CASE_FLT_FN (BUILT_IN_LDEXP):
2089       builtin_optab = ldexp_optab; break;
2090     CASE_FLT_FN (BUILT_IN_FMOD):
2091       builtin_optab = fmod_optab; break;
2092     CASE_FLT_FN (BUILT_IN_REMAINDER):
2093     CASE_FLT_FN (BUILT_IN_DREM):
2094       builtin_optab = remainder_optab; break;
2095     default:
2096       gcc_unreachable ();
2097     }
2098
2099   /* Make a suitable register to place result in.  */
2100   mode = TYPE_MODE (TREE_TYPE (exp));
2101
2102   /* Before working hard, check whether the instruction is available.  */
2103   if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2104     return NULL_RTX;
2105
2106   target = gen_reg_rtx (mode);
2107
2108   if (! flag_errno_math || ! HONOR_NANS (mode))
2109     errno_set = false;
2110
2111   /* Always stabilize the argument list.  */
2112   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2113   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2114
2115   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2116   op1 = expand_normal (arg1);
2117
2118   start_sequence ();
2119
2120   /* Compute into TARGET.
2121      Set TARGET to wherever the result comes back.  */
2122   target = expand_binop (mode, builtin_optab, op0, op1,
2123                          target, 0, OPTAB_DIRECT);
2124
2125   /* If we were unable to expand via the builtin, stop the sequence
2126      (without outputting the insns) and call to the library function
2127      with the stabilized argument list.  */
2128   if (target == 0)
2129     {
2130       end_sequence ();
2131       return expand_call (exp, target, target == const0_rtx);
2132     }
2133
2134   if (errno_set)
2135     expand_errno_check (exp, target);
2136
2137   /* Output the entire sequence.  */
2138   insns = get_insns ();
2139   end_sequence ();
2140   emit_insn (insns);
2141
2142   return target;
2143 }
2144
2145 /* Expand a call to the builtin sin and cos math functions.
2146    Return NULL_RTX if a normal call should be emitted rather than expanding the
2147    function in-line.  EXP is the expression that is a call to the builtin
2148    function; if convenient, the result should be placed in TARGET.
2149    SUBTARGET may be used as the target for computing one of EXP's
2150    operands.  */
2151
2152 static rtx
2153 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2154 {
2155   optab builtin_optab;
2156   rtx op0, insns;
2157   tree fndecl = get_callee_fndecl (exp);
2158   enum machine_mode mode;
2159   tree arg;
2160
2161   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2162     return NULL_RTX;
2163
2164   arg = CALL_EXPR_ARG (exp, 0);
2165
2166   switch (DECL_FUNCTION_CODE (fndecl))
2167     {
2168     CASE_FLT_FN (BUILT_IN_SIN):
2169     CASE_FLT_FN (BUILT_IN_COS):
2170       builtin_optab = sincos_optab; break;
2171     default:
2172       gcc_unreachable ();
2173     }
2174
2175   /* Make a suitable register to place result in.  */
2176   mode = TYPE_MODE (TREE_TYPE (exp));
2177
2178   /* Check if sincos insn is available, otherwise fallback
2179      to sin or cos insn.  */
2180   if (optab_handler (builtin_optab, mode)->insn_code == CODE_FOR_nothing)
2181     switch (DECL_FUNCTION_CODE (fndecl))
2182       {
2183       CASE_FLT_FN (BUILT_IN_SIN):
2184         builtin_optab = sin_optab; break;
2185       CASE_FLT_FN (BUILT_IN_COS):
2186         builtin_optab = cos_optab; break;
2187       default:
2188         gcc_unreachable ();
2189       }
2190
2191   /* Before working hard, check whether the instruction is available.  */
2192   if (optab_handler (builtin_optab, mode)->insn_code != CODE_FOR_nothing)
2193     {
2194       target = gen_reg_rtx (mode);
2195
2196       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2197          need to expand the argument again.  This way, we will not perform
2198          side-effects more the once.  */
2199       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2200
2201       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2202
2203       start_sequence ();
2204
2205       /* Compute into TARGET.
2206          Set TARGET to wherever the result comes back.  */
2207       if (builtin_optab == sincos_optab)
2208         {
2209           int result;
2210
2211           switch (DECL_FUNCTION_CODE (fndecl))
2212             {
2213             CASE_FLT_FN (BUILT_IN_SIN):
2214               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2215               break;
2216             CASE_FLT_FN (BUILT_IN_COS):
2217               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2218               break;
2219             default:
2220               gcc_unreachable ();
2221             }
2222           gcc_assert (result);
2223         }
2224       else
2225         {
2226           target = expand_unop (mode, builtin_optab, op0, target, 0);
2227         }
2228
2229       if (target != 0)
2230         {
2231           /* Output the entire sequence.  */
2232           insns = get_insns ();
2233           end_sequence ();
2234           emit_insn (insns);
2235           return target;
2236         }
2237
2238       /* If we were unable to expand via the builtin, stop the sequence
2239          (without outputting the insns) and call to the library function
2240          with the stabilized argument list.  */
2241       end_sequence ();
2242     }
2243
2244   target = expand_call (exp, target, target == const0_rtx);
2245
2246   return target;
2247 }
2248
2249 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2250    return an RTL instruction code that implements the functionality.
2251    If that isn't possible or available return CODE_FOR_nothing.  */
2252
2253 static enum insn_code
2254 interclass_mathfn_icode (tree arg, tree fndecl)
2255 {
2256   bool errno_set = false;
2257   optab builtin_optab = 0;
2258   enum machine_mode mode;
2259
2260   switch (DECL_FUNCTION_CODE (fndecl))
2261     {
2262     CASE_FLT_FN (BUILT_IN_ILOGB):
2263       errno_set = true; builtin_optab = ilogb_optab; break;
2264     CASE_FLT_FN (BUILT_IN_ISINF):
2265       builtin_optab = isinf_optab; break;
2266     case BUILT_IN_ISNORMAL:
2267     case BUILT_IN_ISFINITE:
2268     CASE_FLT_FN (BUILT_IN_FINITE):
2269     case BUILT_IN_FINITED32:
2270     case BUILT_IN_FINITED64:
2271     case BUILT_IN_FINITED128:
2272     case BUILT_IN_ISINFD32:
2273     case BUILT_IN_ISINFD64:
2274     case BUILT_IN_ISINFD128:
2275       /* These builtins have no optabs (yet).  */
2276       break;
2277     default:
2278       gcc_unreachable ();
2279     }
2280
2281   /* There's no easy way to detect the case we need to set EDOM.  */
2282   if (flag_errno_math && errno_set)
2283     return CODE_FOR_nothing;
2284
2285   /* Optab mode depends on the mode of the input argument.  */
2286   mode = TYPE_MODE (TREE_TYPE (arg));
2287
2288   if (builtin_optab)
2289     return optab_handler (builtin_optab, mode)->insn_code;
2290   return CODE_FOR_nothing;
2291 }
2292
2293 /* Expand a call to one of the builtin math functions that operate on
2294    floating point argument and output an integer result (ilogb, isinf,
2295    isnan, etc).
2296    Return 0 if a normal call should be emitted rather than expanding the
2297    function in-line.  EXP is the expression that is a call to the builtin
2298    function; if convenient, the result should be placed in TARGET.
2299    SUBTARGET may be used as the target for computing one of EXP's operands.  */
2300
2301 static rtx
2302 expand_builtin_interclass_mathfn (tree exp, rtx target, rtx subtarget)
2303 {
2304   enum insn_code icode = CODE_FOR_nothing;
2305   rtx op0;
2306   tree fndecl = get_callee_fndecl (exp);
2307   enum machine_mode mode;
2308   tree arg;
2309
2310   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2311     return NULL_RTX;
2312
2313   arg = CALL_EXPR_ARG (exp, 0);
2314   icode = interclass_mathfn_icode (arg, fndecl);
2315   mode = TYPE_MODE (TREE_TYPE (arg));
2316
2317   if (icode != CODE_FOR_nothing)
2318     {
2319       /* Make a suitable register to place result in.  */
2320       if (!target
2321           || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
2322          target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2323
2324       gcc_assert (insn_data[icode].operand[0].predicate
2325                   (target, GET_MODE (target)));
2326
2327       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2328          need to expand the argument again.  This way, we will not perform
2329          side-effects more the once.  */
2330       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2331
2332       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2333
2334       if (mode != GET_MODE (op0))
2335         op0 = convert_to_mode (mode, op0, 0);
2336
2337       /* Compute into TARGET.
2338          Set TARGET to wherever the result comes back.  */
2339       emit_unop_insn (icode, target, op0, UNKNOWN);
2340       return target;
2341     }
2342
2343   return NULL_RTX;
2344 }
2345
2346 /* Expand a call to the builtin sincos math function.
2347    Return NULL_RTX if a normal call should be emitted rather than expanding the
2348    function in-line.  EXP is the expression that is a call to the builtin
2349    function.  */
2350
2351 static rtx
2352 expand_builtin_sincos (tree exp)
2353 {
2354   rtx op0, op1, op2, target1, target2;
2355   enum machine_mode mode;
2356   tree arg, sinp, cosp;
2357   int result;
2358   location_t loc = EXPR_LOCATION (exp);
2359
2360   if (!validate_arglist (exp, REAL_TYPE,
2361                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2362     return NULL_RTX;
2363
2364   arg = CALL_EXPR_ARG (exp, 0);
2365   sinp = CALL_EXPR_ARG (exp, 1);
2366   cosp = CALL_EXPR_ARG (exp, 2);
2367
2368   /* Make a suitable register to place result in.  */
2369   mode = TYPE_MODE (TREE_TYPE (arg));
2370
2371   /* Check if sincos insn is available, otherwise emit the call.  */
2372   if (optab_handler (sincos_optab, mode)->insn_code == CODE_FOR_nothing)
2373     return NULL_RTX;
2374
2375   target1 = gen_reg_rtx (mode);
2376   target2 = gen_reg_rtx (mode);
2377
2378   op0 = expand_normal (arg);
2379   op1 = expand_normal (build_fold_indirect_ref_loc (loc, sinp));
2380   op2 = expand_normal (build_fold_indirect_ref_loc (loc, cosp));
2381
2382   /* Compute into target1 and target2.
2383      Set TARGET to wherever the result comes back.  */
2384   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2385   gcc_assert (result);
2386
2387   /* Move target1 and target2 to the memory locations indicated
2388      by op1 and op2.  */
2389   emit_move_insn (op1, target1);
2390   emit_move_insn (op2, target2);
2391
2392   return const0_rtx;
2393 }
2394
2395 /* Expand a call to the internal cexpi builtin to the sincos math function.
2396    EXP is the expression that is a call to the builtin function; if convenient,
2397    the result should be placed in TARGET.  SUBTARGET may be used as the target
2398    for computing one of EXP's operands.  */
2399
2400 static rtx
2401 expand_builtin_cexpi (tree exp, rtx target, rtx subtarget)
2402 {
2403   tree fndecl = get_callee_fndecl (exp);
2404   tree arg, type;
2405   enum machine_mode mode;
2406   rtx op0, op1, op2;
2407   location_t loc = EXPR_LOCATION (exp);
2408
2409   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2410     return NULL_RTX;
2411
2412   arg = CALL_EXPR_ARG (exp, 0);
2413   type = TREE_TYPE (arg);
2414   mode = TYPE_MODE (TREE_TYPE (arg));
2415
2416   /* Try expanding via a sincos optab, fall back to emitting a libcall
2417      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2418      is only generated from sincos, cexp or if we have either of them.  */
2419   if (optab_handler (sincos_optab, mode)->insn_code != CODE_FOR_nothing)
2420     {
2421       op1 = gen_reg_rtx (mode);
2422       op2 = gen_reg_rtx (mode);
2423
2424       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2425
2426       /* Compute into op1 and op2.  */
2427       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2428     }
2429   else if (TARGET_HAS_SINCOS)
2430     {
2431       tree call, fn = NULL_TREE;
2432       tree top1, top2;
2433       rtx op1a, op2a;
2434
2435       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2436         fn = built_in_decls[BUILT_IN_SINCOSF];
2437       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2438         fn = built_in_decls[BUILT_IN_SINCOS];
2439       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2440         fn = built_in_decls[BUILT_IN_SINCOSL];
2441       else
2442         gcc_unreachable ();
2443
2444       op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2445       op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2446       op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2447       op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2448       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2449       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2450
2451       /* Make sure not to fold the sincos call again.  */
2452       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2453       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2454                                       call, 3, arg, top1, top2));
2455     }
2456   else
2457     {
2458       tree call, fn = NULL_TREE, narg;
2459       tree ctype = build_complex_type (type);
2460
2461       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2462         fn = built_in_decls[BUILT_IN_CEXPF];
2463       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2464         fn = built_in_decls[BUILT_IN_CEXP];
2465       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2466         fn = built_in_decls[BUILT_IN_CEXPL];
2467       else
2468         gcc_unreachable ();
2469
2470       /* If we don't have a decl for cexp create one.  This is the
2471          friendliest fallback if the user calls __builtin_cexpi
2472          without full target C99 function support.  */
2473       if (fn == NULL_TREE)
2474         {
2475           tree fntype;
2476           const char *name = NULL;
2477
2478           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2479             name = "cexpf";
2480           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2481             name = "cexp";
2482           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2483             name = "cexpl";
2484
2485           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2486           fn = build_fn_decl (name, fntype);
2487         }
2488
2489       narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2490                           build_real (type, dconst0), arg);
2491
2492       /* Make sure not to fold the cexp call again.  */
2493       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2494       return expand_expr (build_call_nary (ctype, call, 1, narg),
2495                           target, VOIDmode, EXPAND_NORMAL);
2496     }
2497
2498   /* Now build the proper return type.  */
2499   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2500                               make_tree (TREE_TYPE (arg), op2),
2501                               make_tree (TREE_TYPE (arg), op1)),
2502                       target, VOIDmode, EXPAND_NORMAL);
2503 }
2504
2505 /* Conveniently construct a function call expression.  FNDECL names the
2506    function to be called, N is the number of arguments, and the "..."
2507    parameters are the argument expressions.  Unlike build_call_exr
2508    this doesn't fold the call, hence it will always return a CALL_EXPR.  */
2509
2510 static tree
2511 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2512 {
2513   va_list ap;
2514   tree fntype = TREE_TYPE (fndecl);
2515   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2516
2517   va_start (ap, n);
2518   fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2519   va_end (ap);
2520   SET_EXPR_LOCATION (fn, loc);
2521   return fn;
2522 }
2523 #define build_call_nofold(...) \
2524   build_call_nofold_loc (UNKNOWN_LOCATION, __VA_ARGS__)
2525
2526 /* Expand a call to one of the builtin rounding functions gcc defines
2527    as an extension (lfloor and lceil).  As these are gcc extensions we
2528    do not need to worry about setting errno to EDOM.
2529    If expanding via optab fails, lower expression to (int)(floor(x)).
2530    EXP is the expression that is a call to the builtin function;
2531    if convenient, the result should be placed in TARGET.  */
2532
2533 static rtx
2534 expand_builtin_int_roundingfn (tree exp, rtx target)
2535 {
2536   convert_optab builtin_optab;
2537   rtx op0, insns, tmp;
2538   tree fndecl = get_callee_fndecl (exp);
2539   enum built_in_function fallback_fn;
2540   tree fallback_fndecl;
2541   enum machine_mode mode;
2542   tree arg;
2543
2544   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2545     gcc_unreachable ();
2546
2547   arg = CALL_EXPR_ARG (exp, 0);
2548
2549   switch (DECL_FUNCTION_CODE (fndecl))
2550     {
2551     CASE_FLT_FN (BUILT_IN_LCEIL):
2552     CASE_FLT_FN (BUILT_IN_LLCEIL):
2553       builtin_optab = lceil_optab;
2554       fallback_fn = BUILT_IN_CEIL;
2555       break;
2556
2557     CASE_FLT_FN (BUILT_IN_LFLOOR):
2558     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2559       builtin_optab = lfloor_optab;
2560       fallback_fn = BUILT_IN_FLOOR;
2561       break;
2562
2563     default:
2564       gcc_unreachable ();
2565     }
2566
2567   /* Make a suitable register to place result in.  */
2568   mode = TYPE_MODE (TREE_TYPE (exp));
2569
2570   target = gen_reg_rtx (mode);
2571
2572   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2573      need to expand the argument again.  This way, we will not perform
2574      side-effects more the once.  */
2575   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2576
2577   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2578
2579   start_sequence ();
2580
2581   /* Compute into TARGET.  */
2582   if (expand_sfix_optab (target, op0, builtin_optab))
2583     {
2584       /* Output the entire sequence.  */
2585       insns = get_insns ();
2586       end_sequence ();
2587       emit_insn (insns);
2588       return target;
2589     }
2590
2591   /* If we were unable to expand via the builtin, stop the sequence
2592      (without outputting the insns).  */
2593   end_sequence ();
2594
2595   /* Fall back to floating point rounding optab.  */
2596   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2597
2598   /* For non-C99 targets we may end up without a fallback fndecl here
2599      if the user called __builtin_lfloor directly.  In this case emit
2600      a call to the floor/ceil variants nevertheless.  This should result
2601      in the best user experience for not full C99 targets.  */
2602   if (fallback_fndecl == NULL_TREE)
2603     {
2604       tree fntype;
2605       const char *name = NULL;
2606
2607       switch (DECL_FUNCTION_CODE (fndecl))
2608         {
2609         case BUILT_IN_LCEIL:
2610         case BUILT_IN_LLCEIL:
2611           name = "ceil";
2612           break;
2613         case BUILT_IN_LCEILF:
2614         case BUILT_IN_LLCEILF:
2615           name = "ceilf";
2616           break;
2617         case BUILT_IN_LCEILL:
2618         case BUILT_IN_LLCEILL:
2619           name = "ceill";
2620           break;
2621         case BUILT_IN_LFLOOR:
2622         case BUILT_IN_LLFLOOR:
2623           name = "floor";
2624           break;
2625         case BUILT_IN_LFLOORF:
2626         case BUILT_IN_LLFLOORF:
2627           name = "floorf";
2628           break;
2629         case BUILT_IN_LFLOORL:
2630         case BUILT_IN_LLFLOORL:
2631           name = "floorl";
2632           break;
2633         default:
2634           gcc_unreachable ();
2635         }
2636
2637       fntype = build_function_type_list (TREE_TYPE (arg),
2638                                          TREE_TYPE (arg), NULL_TREE);
2639       fallback_fndecl = build_fn_decl (name, fntype);
2640     }
2641
2642   exp = build_call_nofold (fallback_fndecl, 1, arg);
2643
2644   tmp = expand_normal (exp);
2645
2646   /* Truncate the result of floating point optab to integer
2647      via expand_fix ().  */
2648   target = gen_reg_rtx (mode);
2649   expand_fix (target, tmp, 0);
2650
2651   return target;
2652 }
2653
2654 /* Expand a call to one of the builtin math functions doing integer
2655    conversion (lrint).
2656    Return 0 if a normal call should be emitted rather than expanding the
2657    function in-line.  EXP is the expression that is a call to the builtin
2658    function; if convenient, the result should be placed in TARGET.  */
2659
2660 static rtx
2661 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2662 {
2663   convert_optab builtin_optab;
2664   rtx op0, insns;
2665   tree fndecl = get_callee_fndecl (exp);
2666   tree arg;
2667   enum machine_mode mode;
2668
2669   /* There's no easy way to detect the case we need to set EDOM.  */
2670   if (flag_errno_math)
2671     return NULL_RTX;
2672
2673   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2674      gcc_unreachable ();
2675
2676   arg = CALL_EXPR_ARG (exp, 0);
2677
2678   switch (DECL_FUNCTION_CODE (fndecl))
2679     {
2680     CASE_FLT_FN (BUILT_IN_LRINT):
2681     CASE_FLT_FN (BUILT_IN_LLRINT):
2682       builtin_optab = lrint_optab; break;
2683     CASE_FLT_FN (BUILT_IN_LROUND):
2684     CASE_FLT_FN (BUILT_IN_LLROUND):
2685       builtin_optab = lround_optab; break;
2686     default:
2687       gcc_unreachable ();
2688     }
2689
2690   /* Make a suitable register to place result in.  */
2691   mode = TYPE_MODE (TREE_TYPE (exp));
2692
2693   target = gen_reg_rtx (mode);
2694
2695   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2696      need to expand the argument again.  This way, we will not perform
2697      side-effects more the once.  */
2698   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2699
2700   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2701
2702   start_sequence ();
2703
2704   if (expand_sfix_optab (target, op0, builtin_optab))
2705     {
2706       /* Output the entire sequence.  */
2707       insns = get_insns ();
2708       end_sequence ();
2709       emit_insn (insns);
2710       return target;
2711     }
2712
2713   /* If we were unable to expand via the builtin, stop the sequence
2714      (without outputting the insns) and call to the library function
2715      with the stabilized argument list.  */
2716   end_sequence ();
2717
2718   target = expand_call (exp, target, target == const0_rtx);
2719
2720   return target;
2721 }
2722
2723 /* To evaluate powi(x,n), the floating point value x raised to the
2724    constant integer exponent n, we use a hybrid algorithm that
2725    combines the "window method" with look-up tables.  For an
2726    introduction to exponentiation algorithms and "addition chains",
2727    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2728    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2729    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2730    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2731
2732 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2733    multiplications to inline before calling the system library's pow
2734    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2735    so this default never requires calling pow, powf or powl.  */
2736
2737 #ifndef POWI_MAX_MULTS
2738 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2739 #endif
2740
2741 /* The size of the "optimal power tree" lookup table.  All
2742    exponents less than this value are simply looked up in the
2743    powi_table below.  This threshold is also used to size the
2744    cache of pseudo registers that hold intermediate results.  */
2745 #define POWI_TABLE_SIZE 256
2746
2747 /* The size, in bits of the window, used in the "window method"
2748    exponentiation algorithm.  This is equivalent to a radix of
2749    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2750 #define POWI_WINDOW_SIZE 3
2751
2752 /* The following table is an efficient representation of an
2753    "optimal power tree".  For each value, i, the corresponding
2754    value, j, in the table states than an optimal evaluation
2755    sequence for calculating pow(x,i) can be found by evaluating
2756    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2757    100 integers is given in Knuth's "Seminumerical algorithms".  */
2758
2759 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2760   {
2761       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2762       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2763       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2764      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2765      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2766      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2767      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2768      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2769      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2770      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2771      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2772      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2773      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2774      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2775      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2776      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2777      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2778      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2779      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2780      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2781      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2782      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2783      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2784      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2785      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2786     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2787     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2788     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2789     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2790     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2791     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2792     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2793   };
2794
2795
2796 /* Return the number of multiplications required to calculate
2797    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2798    subroutine of powi_cost.  CACHE is an array indicating
2799    which exponents have already been calculated.  */
2800
2801 static int
2802 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2803 {
2804   /* If we've already calculated this exponent, then this evaluation
2805      doesn't require any additional multiplications.  */
2806   if (cache[n])
2807     return 0;
2808
2809   cache[n] = true;
2810   return powi_lookup_cost (n - powi_table[n], cache)
2811          + powi_lookup_cost (powi_table[n], cache) + 1;
2812 }
2813
2814 /* Return the number of multiplications required to calculate
2815    powi(x,n) for an arbitrary x, given the exponent N.  This
2816    function needs to be kept in sync with expand_powi below.  */
2817
2818 static int
2819 powi_cost (HOST_WIDE_INT n)
2820 {
2821   bool cache[POWI_TABLE_SIZE];
2822   unsigned HOST_WIDE_INT digit;
2823   unsigned HOST_WIDE_INT val;
2824   int result;
2825
2826   if (n == 0)
2827     return 0;
2828
2829   /* Ignore the reciprocal when calculating the cost.  */
2830   val = (n < 0) ? -n : n;
2831
2832   /* Initialize the exponent cache.  */
2833   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2834   cache[1] = true;
2835
2836   result = 0;
2837
2838   while (val >= POWI_TABLE_SIZE)
2839     {
2840       if (val & 1)
2841         {
2842           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2843           result += powi_lookup_cost (digit, cache)
2844                     + POWI_WINDOW_SIZE + 1;
2845           val >>= POWI_WINDOW_SIZE;
2846         }
2847       else
2848         {
2849           val >>= 1;
2850           result++;
2851         }
2852     }
2853
2854   return result + powi_lookup_cost (val, cache);
2855 }
2856
2857 /* Recursive subroutine of expand_powi.  This function takes the array,
2858    CACHE, of already calculated exponents and an exponent N and returns
2859    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2860
2861 static rtx
2862 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2863 {
2864   unsigned HOST_WIDE_INT digit;
2865   rtx target, result;
2866   rtx op0, op1;
2867
2868   if (n < POWI_TABLE_SIZE)
2869     {
2870       if (cache[n])
2871         return cache[n];
2872
2873       target = gen_reg_rtx (mode);
2874       cache[n] = target;
2875
2876       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2877       op1 = expand_powi_1 (mode, powi_table[n], cache);
2878     }
2879   else if (n & 1)
2880     {
2881       target = gen_reg_rtx (mode);
2882       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2883       op0 = expand_powi_1 (mode, n - digit, cache);
2884       op1 = expand_powi_1 (mode, digit, cache);
2885     }
2886   else
2887     {
2888       target = gen_reg_rtx (mode);
2889       op0 = expand_powi_1 (mode, n >> 1, cache);
2890       op1 = op0;
2891     }
2892
2893   result = expand_mult (mode, op0, op1, target, 0);
2894   if (result != target)
2895     emit_move_insn (target, result);
2896   return target;
2897 }
2898
2899 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
2900    floating point operand in mode MODE, and N is the exponent.  This
2901    function needs to be kept in sync with powi_cost above.  */
2902
2903 static rtx
2904 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2905 {
2906   unsigned HOST_WIDE_INT val;
2907   rtx cache[POWI_TABLE_SIZE];
2908   rtx result;
2909
2910   if (n == 0)
2911     return CONST1_RTX (mode);
2912
2913   val = (n < 0) ? -n : n;
2914
2915   memset (cache, 0, sizeof (cache));
2916   cache[1] = x;
2917
2918   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2919
2920   /* If the original exponent was negative, reciprocate the result.  */
2921   if (n < 0)
2922     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2923                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2924
2925   return result;
2926 }
2927
2928 /* Expand a call to the pow built-in mathematical function.  Return NULL_RTX if
2929    a normal call should be emitted rather than expanding the function
2930    in-line.  EXP is the expression that is a call to the builtin
2931    function; if convenient, the result should be placed in TARGET.  */
2932
2933 static rtx
2934 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
2935 {
2936   tree arg0, arg1;
2937   tree fn, narg0;
2938   tree type = TREE_TYPE (exp);
2939   REAL_VALUE_TYPE cint, c, c2;
2940   HOST_WIDE_INT n;
2941   rtx op, op2;
2942   enum machine_mode mode = TYPE_MODE (type);
2943
2944   if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2945     return NULL_RTX;
2946
2947   arg0 = CALL_EXPR_ARG (exp, 0);
2948   arg1 = CALL_EXPR_ARG (exp, 1);
2949
2950   if (TREE_CODE (arg1) != REAL_CST
2951       || TREE_OVERFLOW (arg1))
2952     return expand_builtin_mathfn_2 (exp, target, subtarget);
2953
2954   /* Handle constant exponents.  */
2955
2956   /* For integer valued exponents we can expand to an optimal multiplication
2957      sequence using expand_powi.  */
2958   c = TREE_REAL_CST (arg1);
2959   n = real_to_integer (&c);
2960   real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2961   if (real_identical (&c, &cint)
2962       && ((n >= -1 && n <= 2)
2963           || (flag_unsafe_math_optimizations
2964               && optimize_insn_for_speed_p ()
2965               && powi_cost (n) <= POWI_MAX_MULTS)))
2966     {
2967       op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2968       if (n != 1)
2969         {
2970           op = force_reg (mode, op);
2971           op = expand_powi (op, mode, n);
2972         }
2973       return op;
2974     }
2975
2976   narg0 = builtin_save_expr (arg0);
2977
2978   /* If the exponent is not integer valued, check if it is half of an integer.
2979      In this case we can expand to sqrt (x) * x**(n/2).  */
2980   fn = mathfn_built_in (type, BUILT_IN_SQRT);
2981   if (fn != NULL_TREE)
2982     {
2983       real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
2984       n = real_to_integer (&c2);
2985       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
2986       if (real_identical (&c2, &cint)
2987           && ((flag_unsafe_math_optimizations
2988                && optimize_insn_for_speed_p ()
2989                && powi_cost (n/2) <= POWI_MAX_MULTS)
2990               || n == 1))
2991         {
2992           tree call_expr = build_call_nofold (fn, 1, narg0);
2993           /* Use expand_expr in case the newly built call expression
2994              was folded to a non-call.  */
2995           op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
2996           if (n != 1)
2997             {
2998               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
2999               op2 = force_reg (mode, op2);
3000               op2 = expand_powi (op2, mode, abs (n / 2));
3001               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3002                                         0, OPTAB_LIB_WIDEN);
3003               /* If the original exponent was negative, reciprocate the
3004                  result.  */
3005               if (n < 0)
3006                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3007                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3008             }
3009           return op;
3010         }
3011     }
3012
3013   /* Try if the exponent is a third of an integer.  In this case
3014      we can expand to x**(n/3) * cbrt(x)**(n%3).  As cbrt (x) is
3015      different from pow (x, 1./3.) due to rounding and behavior
3016      with negative x we need to constrain this transformation to
3017      unsafe math and positive x or finite math.  */
3018   fn = mathfn_built_in (type, BUILT_IN_CBRT);
3019   if (fn != NULL_TREE
3020       && flag_unsafe_math_optimizations
3021       && (tree_expr_nonnegative_p (arg0)
3022           || !HONOR_NANS (mode)))
3023     {
3024       REAL_VALUE_TYPE dconst3;
3025       real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3026       real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3027       real_round (&c2, mode, &c2);
3028       n = real_to_integer (&c2);
3029       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3030       real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3031       real_convert (&c2, mode, &c2);
3032       if (real_identical (&c2, &c)
3033           && ((optimize_insn_for_speed_p ()
3034                && powi_cost (n/3) <= POWI_MAX_MULTS)
3035               || n == 1))
3036         {
3037           tree call_expr = build_call_nofold (fn, 1,narg0);
3038           op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3039           if (abs (n) % 3 == 2)
3040             op = expand_simple_binop (mode, MULT, op, op, op,
3041                                       0, OPTAB_LIB_WIDEN);
3042           if (n != 1)
3043             {
3044               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3045               op2 = force_reg (mode, op2);
3046               op2 = expand_powi (op2, mode, abs (n / 3));
3047               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3048                                         0, OPTAB_LIB_WIDEN);
3049               /* If the original exponent was negative, reciprocate the
3050                  result.  */
3051               if (n < 0)
3052                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3053                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3054             }
3055           return op;
3056         }
3057     }
3058
3059   /* Fall back to optab expansion.  */
3060   return expand_builtin_mathfn_2 (exp, target, subtarget);
3061 }
3062
3063 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
3064    a normal call should be emitted rather than expanding the function
3065    in-line.  EXP is the expression that is a call to the builtin
3066    function; if convenient, the result should be placed in TARGET.  */
3067
3068 static rtx
3069 expand_builtin_powi (tree exp, rtx target, rtx subtarget)
3070 {
3071   tree arg0, arg1;
3072   rtx op0, op1;
3073   enum machine_mode mode;
3074   enum machine_mode mode2;
3075
3076   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3077     return NULL_RTX;
3078
3079   arg0 = CALL_EXPR_ARG (exp, 0);
3080   arg1 = CALL_EXPR_ARG (exp, 1);
3081   mode = TYPE_MODE (TREE_TYPE (exp));
3082
3083   /* Handle constant power.  */
3084
3085   if (TREE_CODE (arg1) == INTEGER_CST
3086       && !TREE_OVERFLOW (arg1))
3087     {
3088       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3089
3090       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3091          Otherwise, check the number of multiplications required.  */
3092       if ((TREE_INT_CST_HIGH (arg1) == 0
3093            || TREE_INT_CST_HIGH (arg1) == -1)
3094           && ((n >= -1 && n <= 2)
3095               || (optimize_insn_for_speed_p ()
3096                   && powi_cost (n) <= POWI_MAX_MULTS)))
3097         {
3098           op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3099           op0 = force_reg (mode, op0);
3100           return expand_powi (op0, mode, n);
3101         }
3102     }
3103
3104   /* Emit a libcall to libgcc.  */
3105
3106   /* Mode of the 2nd argument must match that of an int.  */
3107   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3108
3109   if (target == NULL_RTX)
3110     target = gen_reg_rtx (mode);
3111
3112   op0 = expand_expr (arg0, subtarget, mode, EXPAND_NORMAL);
3113   if (GET_MODE (op0) != mode)
3114     op0 = convert_to_mode (mode, op0, 0);
3115   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3116   if (GET_MODE (op1) != mode2)
3117     op1 = convert_to_mode (mode2, op1, 0);
3118
3119   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3120                                     target, LCT_CONST, mode, 2,
3121                                     op0, mode, op1, mode2);
3122
3123   return target;
3124 }
3125
3126 /* Expand expression EXP which is a call to the strlen builtin.  Return
3127    NULL_RTX if we failed the caller should emit a normal call, otherwise
3128    try to get the result in TARGET, if convenient.  */
3129
3130 static rtx
3131 expand_builtin_strlen (tree exp, rtx target,
3132                        enum machine_mode target_mode)
3133 {
3134   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3135     return NULL_RTX;
3136   else
3137     {
3138       rtx pat;
3139       tree len;
3140       tree src = CALL_EXPR_ARG (exp, 0);
3141       rtx result, src_reg, char_rtx, before_strlen;
3142       enum machine_mode insn_mode = target_mode, char_mode;
3143       enum insn_code icode = CODE_FOR_nothing;
3144       int align;
3145
3146       /* If the length can be computed at compile-time, return it.  */
3147       len = c_strlen (src, 0);
3148       if (len)
3149         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3150
3151       /* If the length can be computed at compile-time and is constant
3152          integer, but there are side-effects in src, evaluate
3153          src for side-effects, then return len.
3154          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3155          can be optimized into: i++; x = 3;  */
3156       len = c_strlen (src, 1);
3157       if (len && TREE_CODE (len) == INTEGER_CST)
3158         {
3159           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3160           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3161         }
3162
3163       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3164
3165       /* If SRC is not a pointer type, don't do this operation inline.  */
3166       if (align == 0)
3167         return NULL_RTX;
3168
3169       /* Bail out if we can't compute strlen in the right mode.  */
3170       while (insn_mode != VOIDmode)
3171         {
3172           icode = optab_handler (strlen_optab, insn_mode)->insn_code;
3173           if (icode != CODE_FOR_nothing)
3174             break;
3175
3176           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3177         }
3178       if (insn_mode == VOIDmode)
3179         return NULL_RTX;
3180
3181       /* Make a place to write the result of the instruction.  */
3182       result = target;
3183       if (! (result != 0
3184              && REG_P (result)
3185              && GET_MODE (result) == insn_mode
3186              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3187         result = gen_reg_rtx (insn_mode);
3188
3189       /* Make a place to hold the source address.  We will not expand
3190          the actual source until we are sure that the expansion will
3191          not fail -- there are trees that cannot be expanded twice.  */
3192       src_reg = gen_reg_rtx (Pmode);
3193
3194       /* Mark the beginning of the strlen sequence so we can emit the
3195          source operand later.  */
3196       before_strlen = get_last_insn ();
3197
3198       char_rtx = const0_rtx;
3199       char_mode = insn_data[(int) icode].operand[2].mode;
3200       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3201                                                             char_mode))
3202         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3203
3204       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3205                              char_rtx, GEN_INT (align));
3206       if (! pat)
3207         return NULL_RTX;
3208       emit_insn (pat);
3209
3210       /* Now that we are assured of success, expand the source.  */
3211       start_sequence ();
3212       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3213       if (pat != src_reg)
3214         emit_move_insn (src_reg, pat);
3215       pat = get_insns ();
3216       end_sequence ();
3217
3218       if (before_strlen)
3219         emit_insn_after (pat, before_strlen);
3220       else
3221         emit_insn_before (pat, get_insns ());
3222
3223       /* Return the value in the proper mode for this function.  */
3224       if (GET_MODE (result) == target_mode)
3225         target = result;
3226       else if (target != 0)
3227         convert_move (target, result, 0);
3228       else
3229         target = convert_to_mode (target_mode, result, 0);
3230
3231       return target;
3232     }
3233 }
3234
3235 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3236    bytes from constant string DATA + OFFSET and return it as target
3237    constant.  */
3238
3239 static rtx
3240 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3241                          enum machine_mode mode)
3242 {
3243   const char *str = (const char *) data;
3244
3245   gcc_assert (offset >= 0
3246               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3247                   <= strlen (str) + 1));
3248
3249   return c_readstr (str + offset, mode);
3250 }
3251
3252 /* Expand a call EXP to the memcpy builtin.
3253    Return NULL_RTX if we failed, the caller should emit a normal call,
3254    otherwise try to get the result in TARGET, if convenient (and in
3255    mode MODE if that's convenient).  */
3256
3257 static rtx
3258 expand_builtin_memcpy (tree exp, rtx target)
3259 {
3260   if (!validate_arglist (exp,
3261                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3262     return NULL_RTX;
3263   else
3264     {
3265       tree dest = CALL_EXPR_ARG (exp, 0);
3266       tree src = CALL_EXPR_ARG (exp, 1);
3267       tree len = CALL_EXPR_ARG (exp, 2);
3268       const char *src_str;
3269       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3270       unsigned int dest_align
3271         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3272       rtx dest_mem, src_mem, dest_addr, len_rtx;
3273       HOST_WIDE_INT expected_size = -1;
3274       unsigned int expected_align = 0;
3275       tree_ann_common_t ann;
3276
3277       /* If DEST is not a pointer type, call the normal function.  */
3278       if (dest_align == 0)
3279         return NULL_RTX;
3280
3281       /* If either SRC is not a pointer type, don't do this
3282          operation in-line.  */
3283       if (src_align == 0)
3284         return NULL_RTX;
3285
3286       ann = tree_common_ann (exp);
3287       if (ann)
3288         stringop_block_profile (ann->stmt, &expected_align, &expected_size);
3289
3290       if (expected_align < dest_align)
3291         expected_align = dest_align;
3292       dest_mem = get_memory_rtx (dest, len);
3293       set_mem_align (dest_mem, dest_align);
3294       len_rtx = expand_normal (len);
3295       src_str = c_getstr (src);
3296
3297       /* If SRC is a string constant and block move would be done
3298          by pieces, we can avoid loading the string from memory
3299          and only stored the computed constants.  */
3300       if (src_str
3301           && CONST_INT_P (len_rtx)
3302           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3303           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3304                                   CONST_CAST (char *, src_str),
3305                                   dest_align, false))
3306         {
3307           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3308                                       builtin_memcpy_read_str,
3309                                       CONST_CAST (char *, src_str),
3310                                       dest_align, false, 0);
3311           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3312           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3313           return dest_mem;
3314         }
3315
3316       src_mem = get_memory_rtx (src, len);
3317       set_mem_align (src_mem, src_align);
3318
3319       /* Copy word part most expediently.  */
3320       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3321                                          CALL_EXPR_TAILCALL (exp)
3322                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3323                                          expected_align, expected_size);
3324
3325       if (dest_addr == 0)
3326         {
3327           dest_addr = force_operand (XEXP (dest_mem, 0), target);
3328           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3329         }
3330       return dest_addr;
3331     }
3332 }
3333
3334 /* Expand a call EXP to the mempcpy builtin.
3335    Return NULL_RTX if we failed; the caller should emit a normal call,
3336    otherwise try to get the result in TARGET, if convenient (and in
3337    mode MODE if that's convenient).  If ENDP is 0 return the
3338    destination pointer, if ENDP is 1 return the end pointer ala
3339    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3340    stpcpy.  */
3341
3342 static rtx
3343 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3344 {
3345   if (!validate_arglist (exp,
3346                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3347     return NULL_RTX;
3348   else
3349     {
3350       tree dest = CALL_EXPR_ARG (exp, 0);
3351       tree src = CALL_EXPR_ARG (exp, 1);
3352       tree len = CALL_EXPR_ARG (exp, 2);
3353       return expand_builtin_mempcpy_args (dest, src, len,
3354                                           target, mode, /*endp=*/ 1);
3355     }
3356 }
3357
3358 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3359    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3360    so that this can also be called without constructing an actual CALL_EXPR.
3361    The other arguments and return value are the same as for
3362    expand_builtin_mempcpy.  */
3363
3364 static rtx
3365 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3366                              rtx target, enum machine_mode mode, int endp)
3367 {
3368     /* If return value is ignored, transform mempcpy into memcpy.  */
3369   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3370     {
3371       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3372       tree result = build_call_nofold (fn, 3, dest, src, len);
3373       return expand_expr (result, target, mode, EXPAND_NORMAL);
3374     }
3375   else
3376     {
3377       const char *src_str;
3378       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3379       unsigned int dest_align
3380         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3381       rtx dest_mem, src_mem, len_rtx;
3382
3383       /* If either SRC or DEST is not a pointer type, don't do this
3384          operation in-line.  */
3385       if (dest_align == 0 || src_align == 0)
3386         return NULL_RTX;
3387
3388       /* If LEN is not constant, call the normal function.  */
3389       if (! host_integerp (len, 1))
3390         return NULL_RTX;
3391
3392       len_rtx = expand_normal (len);
3393       src_str = c_getstr (src);
3394
3395       /* If SRC is a string constant and block move would be done
3396          by pieces, we can avoid loading the string from memory
3397          and only stored the computed constants.  */
3398       if (src_str
3399           && CONST_INT_P (len_rtx)
3400           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3401           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3402                                   CONST_CAST (char *, src_str),
3403                                   dest_align, false))
3404         {
3405           dest_mem = get_memory_rtx (dest, len);
3406           set_mem_align (dest_mem, dest_align);
3407           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3408                                       builtin_memcpy_read_str,
3409                                       CONST_CAST (char *, src_str),
3410                                       dest_align, false, endp);
3411           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3412           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3413           return dest_mem;
3414         }
3415
3416       if (CONST_INT_P (len_rtx)
3417           && can_move_by_pieces (INTVAL (len_rtx),
3418                                  MIN (dest_align, src_align)))
3419         {
3420           dest_mem = get_memory_rtx (dest, len);
3421           set_mem_align (dest_mem, dest_align);
3422           src_mem = get_memory_rtx (src, len);
3423           set_mem_align (src_mem, src_align);
3424           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3425                                      MIN (dest_align, src_align), endp);
3426           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3427           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3428           return dest_mem;
3429         }
3430
3431       return NULL_RTX;
3432     }
3433 }
3434
3435 #ifndef HAVE_movstr
3436 # define HAVE_movstr 0
3437 # define CODE_FOR_movstr CODE_FOR_nothing
3438 #endif
3439
3440 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3441    we failed, the caller should emit a normal call, otherwise try to
3442    get the result in TARGET, if convenient.  If ENDP is 0 return the
3443    destination pointer, if ENDP is 1 return the end pointer ala
3444    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3445    stpcpy.  */
3446
3447 static rtx
3448 expand_movstr (tree dest, tree src, rtx target, int endp)
3449 {
3450   rtx end;
3451   rtx dest_mem;
3452   rtx src_mem;
3453   rtx insn;
3454   const struct insn_data * data;
3455
3456   if (!HAVE_movstr)
3457     return NULL_RTX;
3458
3459   dest_mem = get_memory_rtx (dest, NULL);
3460   src_mem = get_memory_rtx (src, NULL);
3461   if (!endp)
3462     {
3463       target = force_reg (Pmode, XEXP (dest_mem, 0));
3464       dest_mem = replace_equiv_address (dest_mem, target);
3465       end = gen_reg_rtx (Pmode);
3466     }
3467   else
3468     {
3469       if (target == 0 || target == const0_rtx)
3470         {
3471           end = gen_reg_rtx (Pmode);
3472           if (target == 0)
3473             target = end;
3474         }
3475       else
3476         end = target;
3477     }
3478
3479   data = insn_data + CODE_FOR_movstr;
3480
3481   if (data->operand[0].mode != VOIDmode)
3482     end = gen_lowpart (data->operand[0].mode, end);
3483
3484   insn = data->genfun (end, dest_mem, src_mem);
3485
3486   gcc_assert (insn);
3487
3488   emit_insn (insn);
3489
3490   /* movstr is supposed to set end to the address of the NUL
3491      terminator.  If the caller requested a mempcpy-like return value,
3492      adjust it.  */
3493   if (endp == 1 && target != const0_rtx)
3494     {
3495       rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3496       emit_move_insn (target, force_operand (tem, NULL_RTX));
3497     }
3498
3499   return target;
3500 }
3501
3502 /* Expand expression EXP, which is a call to the strcpy builtin.  Return
3503    NULL_RTX if we failed the caller should emit a normal call, otherwise
3504    try to get the result in TARGET, if convenient (and in mode MODE if that's
3505    convenient).  */
3506
3507 static rtx
3508 expand_builtin_strcpy (tree exp, rtx target)
3509 {
3510   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3511    {
3512      tree dest = CALL_EXPR_ARG (exp, 0);
3513      tree src = CALL_EXPR_ARG (exp, 1);
3514      return expand_builtin_strcpy_args (dest, src, target);
3515    }
3516    return NULL_RTX;
3517 }
3518
3519 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3520    arguments to the builtin_strcpy call DEST and SRC are broken out
3521    so that this can also be called without constructing an actual CALL_EXPR.
3522    The other arguments and return value are the same as for
3523    expand_builtin_strcpy.  */
3524
3525 static rtx
3526 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3527 {
3528   return expand_movstr (dest, src, target, /*endp=*/0);
3529 }
3530
3531 /* Expand a call EXP to the stpcpy builtin.
3532    Return NULL_RTX if we failed the caller should emit a normal call,
3533    otherwise try to get the result in TARGET, if convenient (and in
3534    mode MODE if that's convenient).  */
3535
3536 static rtx
3537 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3538 {
3539   tree dst, src;
3540   location_t loc = EXPR_LOCATION (exp);
3541
3542   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3543     return NULL_RTX;
3544
3545   dst = CALL_EXPR_ARG (exp, 0);
3546   src = CALL_EXPR_ARG (exp, 1);
3547
3548   /* If return value is ignored, transform stpcpy into strcpy.  */
3549   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3550     {
3551       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3552       tree result = build_call_nofold (fn, 2, dst, src);
3553       return expand_expr (result, target, mode, EXPAND_NORMAL);
3554     }
3555   else
3556     {
3557       tree len, lenp1;
3558       rtx ret;
3559
3560       /* Ensure we get an actual string whose length can be evaluated at
3561          compile-time, not an expression containing a string.  This is
3562          because the latter will potentially produce pessimized code
3563          when used to produce the return value.  */
3564       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3565         return expand_movstr (dst, src, target, /*endp=*/2);
3566
3567       lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3568       ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3569                                          target, mode, /*endp=*/2);
3570
3571       if (ret)
3572         return ret;
3573
3574       if (TREE_CODE (len) == INTEGER_CST)
3575         {
3576           rtx len_rtx = expand_normal (len);
3577
3578           if (CONST_INT_P (len_rtx))
3579             {
3580               ret = expand_builtin_strcpy_args (dst, src, target);
3581
3582               if (ret)
3583                 {
3584                   if (! target)
3585                     {
3586                       if (mode != VOIDmode)
3587                         target = gen_reg_rtx (mode);
3588                       else
3589                         target = gen_reg_rtx (GET_MODE (ret));
3590                     }
3591                   if (GET_MODE (target) != GET_MODE (ret))
3592                     ret = gen_lowpart (GET_MODE (target), ret);
3593
3594                   ret = plus_constant (ret, INTVAL (len_rtx));
3595                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3596                   gcc_assert (ret);
3597
3598                   return target;
3599                 }
3600             }
3601         }
3602
3603       return expand_movstr (dst, src, target, /*endp=*/2);
3604     }
3605 }
3606
3607 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3608    bytes from constant string DATA + OFFSET and return it as target
3609    constant.  */
3610
3611 rtx
3612 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3613                           enum machine_mode mode)
3614 {
3615   const char *str = (const char *) data;
3616
3617   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3618     return const0_rtx;
3619
3620   return c_readstr (str + offset, mode);
3621 }
3622
3623 /* Expand expression EXP, which is a call to the strncpy builtin.  Return
3624    NULL_RTX if we failed the caller should emit a normal call.  */
3625
3626 static rtx
3627 expand_builtin_strncpy (tree exp, rtx target)
3628 {
3629   location_t loc = EXPR_LOCATION (exp);
3630
3631   if (validate_arglist (exp,
3632                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3633     {
3634       tree dest = CALL_EXPR_ARG (exp, 0);
3635       tree src = CALL_EXPR_ARG (exp, 1);
3636       tree len = CALL_EXPR_ARG (exp, 2);
3637       tree slen = c_strlen (src, 1);
3638
3639       /* We must be passed a constant len and src parameter.  */
3640       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3641         return NULL_RTX;
3642
3643       slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3644
3645       /* We're required to pad with trailing zeros if the requested
3646          len is greater than strlen(s2)+1.  In that case try to
3647          use store_by_pieces, if it fails, punt.  */
3648       if (tree_int_cst_lt (slen, len))
3649         {
3650           unsigned int dest_align
3651             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3652           const char *p = c_getstr (src);
3653           rtx dest_mem;
3654
3655           if (!p || dest_align == 0 || !host_integerp (len, 1)
3656               || !can_store_by_pieces (tree_low_cst (len, 1),
3657                                        builtin_strncpy_read_str,
3658                                        CONST_CAST (char *, p),
3659                                        dest_align, false))
3660             return NULL_RTX;
3661
3662           dest_mem = get_memory_rtx (dest, len);
3663           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3664                            builtin_strncpy_read_str,
3665                            CONST_CAST (char *, p), dest_align, false, 0);
3666           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3667           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3668           return dest_mem;
3669         }
3670     }
3671   return NULL_RTX;
3672 }
3673
3674 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3675    bytes from constant string DATA + OFFSET and return it as target
3676    constant.  */
3677
3678 rtx
3679 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3680                          enum machine_mode mode)
3681 {
3682   const char *c = (const char *) data;
3683   char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3684
3685   memset (p, *c, GET_MODE_SIZE (mode));
3686
3687   return c_readstr (p, mode);
3688 }
3689
3690 /* Callback routine for store_by_pieces.  Return the RTL of a register
3691    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3692    char value given in the RTL register data.  For example, if mode is
3693    4 bytes wide, return the RTL for 0x01010101*data.  */
3694
3695 static rtx
3696 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3697                         enum machine_mode mode)
3698 {
3699   rtx target, coeff;
3700   size_t size;
3701   char *p;
3702
3703   size = GET_MODE_SIZE (mode);
3704   if (size == 1)
3705     return (rtx) data;
3706
3707   p = XALLOCAVEC (char, size);
3708   memset (p, 1, size);
3709   coeff = c_readstr (p, mode);
3710
3711   target = convert_to_mode (mode, (rtx) data, 1);
3712   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3713   return force_reg (mode, target);
3714 }
3715
3716 /* Expand expression EXP, which is a call to the memset builtin.  Return
3717    NULL_RTX if we failed the caller should emit a normal call, otherwise
3718    try to get the result in TARGET, if convenient (and in mode MODE if that's
3719    convenient).  */
3720
3721 static rtx
3722 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3723 {
3724   if (!validate_arglist (exp,
3725                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3726     return NULL_RTX;
3727   else
3728     {
3729       tree dest = CALL_EXPR_ARG (exp, 0);
3730       tree val = CALL_EXPR_ARG (exp, 1);
3731       tree len = CALL_EXPR_ARG (exp, 2);
3732       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3733     }
3734 }
3735
3736 /* Helper function to do the actual work for expand_builtin_memset.  The
3737    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3738    so that this can also be called without constructing an actual CALL_EXPR.
3739    The other arguments and return value are the same as for
3740    expand_builtin_memset.  */
3741
3742 static rtx
3743 expand_builtin_memset_args (tree dest, tree val, tree len,
3744                             rtx target, enum machine_mode mode, tree orig_exp)
3745 {
3746   tree fndecl, fn;
3747   enum built_in_function fcode;
3748   char c;
3749   unsigned int dest_align;
3750   rtx dest_mem, dest_addr, len_rtx;
3751   HOST_WIDE_INT expected_size = -1;
3752   unsigned int expected_align = 0;
3753   tree_ann_common_t ann;
3754
3755   dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3756
3757   /* If DEST is not a pointer type, don't do this operation in-line.  */
3758   if (dest_align == 0)
3759     return NULL_RTX;
3760
3761   ann = tree_common_ann (orig_exp);
3762   if (ann)
3763     stringop_block_profile (ann->stmt, &expected_align, &expected_size);
3764
3765   if (expected_align < dest_align)
3766     expected_align = dest_align;
3767
3768   /* If the LEN parameter is zero, return DEST.  */
3769   if (integer_zerop (len))
3770     {
3771       /* Evaluate and ignore VAL in case it has side-effects.  */
3772       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3773       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3774     }
3775
3776   /* Stabilize the arguments in case we fail.  */
3777   dest = builtin_save_expr (dest);
3778   val = builtin_save_expr (val);
3779   len = builtin_save_expr (len);
3780
3781   len_rtx = expand_normal (len);
3782   dest_mem = get_memory_rtx (dest, len);
3783
3784   if (TREE_CODE (val) != INTEGER_CST)
3785     {
3786       rtx val_rtx;
3787
3788       val_rtx = expand_normal (val);
3789       val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3790                                  val_rtx, 0);
3791
3792       /* Assume that we can memset by pieces if we can store
3793        * the coefficients by pieces (in the required modes).
3794        * We can't pass builtin_memset_gen_str as that emits RTL.  */
3795       c = 1;
3796       if (host_integerp (len, 1)
3797           && can_store_by_pieces (tree_low_cst (len, 1),
3798                                   builtin_memset_read_str, &c, dest_align,
3799                                   true))
3800         {
3801           val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3802                                val_rtx);
3803           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3804                            builtin_memset_gen_str, val_rtx, dest_align,
3805                            true, 0);
3806         }
3807       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3808                                         dest_align, expected_align,
3809                                         expected_size))
3810         goto do_libcall;
3811
3812       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3813       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3814       return dest_mem;
3815     }
3816
3817   if (target_char_cast (val, &c))
3818     goto do_libcall;
3819
3820   if (c)
3821     {
3822       if (host_integerp (len, 1)
3823           && can_store_by_pieces (tree_low_cst (len, 1),
3824                                   builtin_memset_read_str, &c, dest_align,
3825                                   true))
3826         store_by_pieces (dest_mem, tree_low_cst (len, 1),
3827                          builtin_memset_read_str, &c, dest_align, true, 0);
3828       else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3829                                         dest_align, expected_align,
3830                                         expected_size))
3831         goto do_libcall;
3832
3833       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3834       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3835       return dest_mem;
3836     }
3837
3838   set_mem_align (dest_mem, dest_align);
3839   dest_addr = clear_storage_hints (dest_mem, len_rtx,
3840                                    CALL_EXPR_TAILCALL (orig_exp)
3841                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3842                                    expected_align, expected_size);
3843
3844   if (dest_addr == 0)
3845     {
3846       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3847       dest_addr = convert_memory_address (ptr_mode, dest_addr);
3848     }
3849
3850   return dest_addr;
3851
3852  do_libcall:
3853   fndecl = get_callee_fndecl (orig_exp);
3854   fcode = DECL_FUNCTION_CODE (fndecl);
3855   if (fcode == BUILT_IN_MEMSET)
3856     fn = build_call_nofold (fndecl, 3, dest, val, len);
3857   else if (fcode == BUILT_IN_BZERO)
3858     fn = build_call_nofold (fndecl, 2, dest, len);
3859   else
3860     gcc_unreachable ();
3861   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3862   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3863   return expand_call (fn, target, target == const0_rtx);
3864 }
3865
3866 /* Expand expression EXP, which is a call to the bzero builtin.  Return
3867    NULL_RTX if we failed the caller should emit a normal call.  */
3868
3869 static rtx
3870 expand_builtin_bzero (tree exp)
3871 {
3872   tree dest, size;
3873   location_t loc = EXPR_LOCATION (exp);
3874
3875   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3876     return NULL_RTX;
3877
3878   dest = CALL_EXPR_ARG (exp, 0);
3879   size = CALL_EXPR_ARG (exp, 1);
3880
3881   /* New argument list transforming bzero(ptr x, int y) to
3882      memset(ptr x, int 0, size_t y).   This is done this way
3883      so that if it isn't expanded inline, we fallback to
3884      calling bzero instead of memset.  */
3885
3886   return expand_builtin_memset_args (dest, integer_zero_node,
3887                                      fold_convert_loc (loc, sizetype, size),
3888                                      const0_rtx, VOIDmode, exp);
3889 }
3890
3891 /* Expand expression EXP, which is a call to the memcmp built-in function.
3892    Return NULL_RTX if we failed and the
3893    caller should emit a normal call, otherwise try to get the result in
3894    TARGET, if convenient (and in mode MODE, if that's convenient).  */
3895
3896 static rtx
3897 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3898                        ATTRIBUTE_UNUSED enum machine_mode mode)
3899 {
3900   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
3901
3902   if (!validate_arglist (exp,
3903                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3904     return NULL_RTX;
3905
3906 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
3907   {
3908     rtx arg1_rtx, arg2_rtx, arg3_rtx;
3909     rtx result;
3910     rtx insn;
3911     tree arg1 = CALL_EXPR_ARG (exp, 0);
3912     tree arg2 = CALL_EXPR_ARG (exp, 1);
3913     tree len = CALL_EXPR_ARG (exp, 2);
3914
3915     int arg1_align
3916       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3917     int arg2_align
3918       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3919     enum machine_mode insn_mode;
3920
3921 #ifdef HAVE_cmpmemsi
3922     if (HAVE_cmpmemsi)
3923       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
3924     else
3925 #endif
3926 #ifdef HAVE_cmpstrnsi
3927     if (HAVE_cmpstrnsi)
3928       insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3929     else
3930 #endif
3931       return NULL_RTX;
3932
3933     /* If we don't have POINTER_TYPE, call the function.  */
3934     if (arg1_align == 0 || arg2_align == 0)
3935       return NULL_RTX;
3936
3937     /* Make a place to write the result of the instruction.  */
3938     result = target;
3939     if (! (result != 0
3940            && REG_P (result) && GET_MODE (result) == insn_mode
3941            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3942       result = gen_reg_rtx (insn_mode);
3943
3944     arg1_rtx = get_memory_rtx (arg1, len);
3945     arg2_rtx = get_memory_rtx (arg2, len);
3946     arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
3947
3948     /* Set MEM_SIZE as appropriate.  */
3949     if (CONST_INT_P (arg3_rtx))
3950       {
3951         set_mem_size (arg1_rtx, arg3_rtx);
3952         set_mem_size (arg2_rtx, arg3_rtx);
3953       }
3954
3955 #ifdef HAVE_cmpmemsi
3956     if (HAVE_cmpmemsi)
3957       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3958                            GEN_INT (MIN (arg1_align, arg2_align)));
3959     else
3960 #endif
3961 #ifdef HAVE_cmpstrnsi
3962     if (HAVE_cmpstrnsi)
3963       insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3964                             GEN_INT (MIN (arg1_align, arg2_align)));
3965     else
3966 #endif
3967       gcc_unreachable ();
3968
3969     if (insn)
3970       emit_insn (insn);
3971     else
3972       emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
3973                                TYPE_MODE (integer_type_node), 3,
3974                                XEXP (arg1_rtx, 0), Pmode,
3975                                XEXP (arg2_rtx, 0), Pmode,
3976                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3977                                                 TYPE_UNSIGNED (sizetype)),
3978                                TYPE_MODE (sizetype));
3979
3980     /* Return the value in the proper mode for this function.  */
3981     mode = TYPE_MODE (TREE_TYPE (exp));
3982     if (GET_MODE (result) == mode)
3983       return result;
3984     else if (target != 0)
3985       {
3986         convert_move (target, result, 0);
3987         return target;
3988       }
3989     else
3990       return convert_to_mode (mode, result, 0);
3991   }
3992 #endif
3993
3994   return NULL_RTX;
3995 }
3996
3997 /* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
3998    if we failed the caller should emit a normal call, otherwise try to get
3999    the result in TARGET, if convenient.  */
4000
4001 static rtx
4002 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
4003 {
4004   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4005     return NULL_RTX;
4006
4007 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4008   if (cmpstr_optab[SImode] != CODE_FOR_nothing
4009       || cmpstrn_optab[SImode] != CODE_FOR_nothing)
4010     {
4011       rtx arg1_rtx, arg2_rtx;
4012       rtx result, insn = NULL_RTX;
4013       tree fndecl, fn;
4014       tree arg1 = CALL_EXPR_ARG (exp, 0);
4015       tree arg2 = CALL_EXPR_ARG (exp, 1);
4016
4017       int arg1_align
4018         = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4019       int arg2_align
4020         = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4021
4022       /* If we don't have POINTER_TYPE, call the function.  */
4023       if (arg1_align == 0 || arg2_align == 0)
4024         return NULL_RTX;
4025
4026       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
4027       arg1 = builtin_save_expr (arg1);
4028       arg2 = builtin_save_expr (arg2);
4029
4030       arg1_rtx = get_memory_rtx (arg1, NULL);
4031       arg2_rtx = get_memory_rtx (arg2, NULL);
4032
4033 #ifdef HAVE_cmpstrsi
4034       /* Try to call cmpstrsi.  */
4035       if (HAVE_cmpstrsi)
4036         {
4037           enum machine_mode insn_mode
4038             = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4039
4040           /* Make a place to write the result of the instruction.  */
4041           result = target;
4042           if (! (result != 0
4043                  && REG_P (result) && GET_MODE (result) == insn_mode
4044                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4045             result = gen_reg_rtx (insn_mode);
4046
4047           insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4048                                GEN_INT (MIN (arg1_align, arg2_align)));
4049         }
4050 #endif
4051 #ifdef HAVE_cmpstrnsi
4052       /* Try to determine at least one length and call cmpstrnsi.  */
4053       if (!insn && HAVE_cmpstrnsi)
4054         {
4055           tree len;
4056           rtx arg3_rtx;
4057
4058           enum machine_mode insn_mode
4059             = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4060           tree len1 = c_strlen (arg1, 1);
4061           tree len2 = c_strlen (arg2, 1);
4062
4063           if (len1)
4064             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4065           if (len2)
4066             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4067
4068           /* If we don't have a constant length for the first, use the length
4069              of the second, if we know it.  We don't require a constant for
4070              this case; some cost analysis could be done if both are available
4071              but neither is constant.  For now, assume they're equally cheap,
4072              unless one has side effects.  If both strings have constant lengths,
4073              use the smaller.  */
4074
4075           if (!len1)
4076             len = len2;
4077           else if (!len2)
4078             len = len1;
4079           else if (TREE_SIDE_EFFECTS (len1))
4080             len = len2;
4081           else if (TREE_SIDE_EFFECTS (len2))
4082             len = len1;
4083           else if (TREE_CODE (len1) != INTEGER_CST)
4084             len = len2;
4085           else if (TREE_CODE (len2) != INTEGER_CST)
4086             len = len1;
4087           else if (tree_int_cst_lt (len1, len2))
4088             len = len1;
4089           else
4090             len = len2;
4091
4092           /* If both arguments have side effects, we cannot optimize.  */
4093           if (!len || TREE_SIDE_EFFECTS (len))
4094             goto do_libcall;
4095
4096           arg3_rtx = expand_normal (len);
4097
4098           /* Make a place to write the result of the instruction.  */
4099           result = target;
4100           if (! (result != 0
4101                  && REG_P (result) && GET_MODE (result) == insn_mode
4102                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4103             result = gen_reg_rtx (insn_mode);
4104
4105           insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4106                                 GEN_INT (MIN (arg1_align, arg2_align)));
4107         }
4108 #endif
4109
4110       if (insn)
4111         {
4112           enum machine_mode mode;
4113           emit_insn (insn);
4114
4115           /* Return the value in the proper mode for this function.  */
4116           mode = TYPE_MODE (TREE_TYPE (exp));
4117           if (GET_MODE (result) == mode)
4118             return result;
4119           if (target == 0)
4120             return convert_to_mode (mode, result, 0);
4121           convert_move (target, result, 0);
4122           return target;
4123         }
4124
4125       /* Expand the library call ourselves using a stabilized argument
4126          list to avoid re-evaluating the function's arguments twice.  */
4127 #ifdef HAVE_cmpstrnsi
4128     do_libcall:
4129 #endif
4130       fndecl = get_callee_fndecl (exp);
4131       fn = build_call_nofold (fndecl, 2, arg1, arg2);
4132       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4133       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4134       return expand_call (fn, target, target == const0_rtx);
4135     }
4136 #endif
4137   return NULL_RTX;
4138 }
4139
4140 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4141    NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4142    the result in TARGET, if convenient.  */
4143
4144 static rtx
4145 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4146                         ATTRIBUTE_UNUSED enum machine_mode mode)
4147 {
4148   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4149
4150   if (!validate_arglist (exp,
4151                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4152     return NULL_RTX;
4153
4154   /* If c_strlen can determine an expression for one of the string
4155      lengths, and it doesn't have side effects, then emit cmpstrnsi
4156      using length MIN(strlen(string)+1, arg3).  */
4157 #ifdef HAVE_cmpstrnsi
4158   if (HAVE_cmpstrnsi)
4159   {
4160     tree len, len1, len2;
4161     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4162     rtx result, insn;
4163     tree fndecl, fn;
4164     tree arg1 = CALL_EXPR_ARG (exp, 0);
4165     tree arg2 = CALL_EXPR_ARG (exp, 1);
4166     tree arg3 = CALL_EXPR_ARG (exp, 2);
4167
4168     int arg1_align
4169       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4170     int arg2_align
4171       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4172     enum machine_mode insn_mode
4173       = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4174
4175     len1 = c_strlen (arg1, 1);
4176     len2 = c_strlen (arg2, 1);
4177
4178     if (len1)
4179       len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
4180     if (len2)
4181       len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
4182
4183     /* If we don't have a constant length for the first, use the length
4184        of the second, if we know it.  We don't require a constant for
4185        this case; some cost analysis could be done if both are available
4186        but neither is constant.  For now, assume they're equally cheap,
4187        unless one has side effects.  If both strings have constant lengths,
4188        use the smaller.  */
4189
4190     if (!len1)
4191       len = len2;
4192     else if (!len2)
4193       len = len1;
4194     else if (TREE_SIDE_EFFECTS (len1))
4195       len = len2;
4196     else if (TREE_SIDE_EFFECTS (len2))
4197       len = len1;
4198     else if (TREE_CODE (len1) != INTEGER_CST)
4199       len = len2;
4200     else if (TREE_CODE (len2) != INTEGER_CST)
4201       len = len1;
4202     else if (tree_int_cst_lt (len1, len2))
4203       len = len1;
4204     else
4205       len = len2;
4206
4207     /* If both arguments have side effects, we cannot optimize.  */
4208     if (!len || TREE_SIDE_EFFECTS (len))
4209       return NULL_RTX;
4210
4211     /* The actual new length parameter is MIN(len,arg3).  */
4212     len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4213                        fold_convert_loc (loc, TREE_TYPE (len), arg3));
4214
4215     /* If we don't have POINTER_TYPE, call the function.  */
4216     if (arg1_align == 0 || arg2_align == 0)
4217       return NULL_RTX;
4218
4219     /* Make a place to write the result of the instruction.  */
4220     result = target;
4221     if (! (result != 0
4222            && REG_P (result) && GET_MODE (result) == insn_mode
4223            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4224       result = gen_reg_rtx (insn_mode);
4225
4226     /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
4227     arg1 = builtin_save_expr (arg1);
4228     arg2 = builtin_save_expr (arg2);
4229     len = builtin_save_expr (len);
4230
4231     arg1_rtx = get_memory_rtx (arg1, len);
4232     arg2_rtx = get_memory_rtx (arg2, len);
4233     arg3_rtx = expand_normal (len);
4234     insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4235                           GEN_INT (MIN (arg1_align, arg2_align)));
4236     if (insn)
4237       {
4238         emit_insn (insn);
4239
4240         /* Return the value in the proper mode for this function.  */
4241         mode = TYPE_MODE (TREE_TYPE (exp));
4242         if (GET_MODE (result) == mode)
4243           return result;
4244         if (target == 0)
4245           return convert_to_mode (mode, result, 0);
4246         convert_move (target, result, 0);
4247         return target;
4248       }
4249
4250     /* Expand the library call ourselves using a stabilized argument
4251        list to avoid re-evaluating the function's arguments twice.  */
4252     fndecl = get_callee_fndecl (exp);
4253     fn = build_call_nofold (fndecl, 3, arg1, arg2, len);
4254     gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4255     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4256     return expand_call (fn, target, target == const0_rtx);
4257   }
4258 #endif
4259   return NULL_RTX;
4260 }
4261
4262 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4263    if that's convenient.  */
4264
4265 rtx
4266 expand_builtin_saveregs (void)
4267 {
4268   rtx val, seq;
4269
4270   /* Don't do __builtin_saveregs more than once in a function.
4271      Save the result of the first call and reuse it.  */
4272   if (saveregs_value != 0)
4273     return saveregs_value;
4274
4275   /* When this function is called, it means that registers must be
4276      saved on entry to this function.  So we migrate the call to the
4277      first insn of this function.  */
4278
4279   start_sequence ();
4280
4281   /* Do whatever the machine needs done in this case.  */
4282   val = targetm.calls.expand_builtin_saveregs ();
4283
4284   seq = get_insns ();
4285   end_sequence ();
4286
4287   saveregs_value = val;
4288
4289   /* Put the insns after the NOTE that starts the function.  If this
4290      is inside a start_sequence, make the outer-level insn chain current, so
4291      the code is placed at the start of the function.  */
4292   push_topmost_sequence ();
4293   emit_insn_after (seq, entry_of_function ());
4294   pop_topmost_sequence ();
4295
4296   return val;
4297 }
4298
4299 /* __builtin_args_info (N) returns word N of the arg space info
4300    for the current function.  The number and meanings of words
4301    is controlled by the definition of CUMULATIVE_ARGS.  */
4302
4303 static rtx
4304 expand_builtin_args_info (tree exp)
4305 {
4306   int nwords = sizeof (CUMULATIVE_ARGS) / sizeof (int);
4307   int *word_ptr = (int *) &crtl->args.info;
4308
4309   gcc_assert (sizeof (CUMULATIVE_ARGS) % sizeof (int) == 0);
4310
4311   if (call_expr_nargs (exp) != 0)
4312     {
4313       if (!host_integerp (CALL_EXPR_ARG (exp, 0), 0))
4314         error ("argument of %<__builtin_args_info%> must be constant");
4315       else
4316         {
4317           HOST_WIDE_INT wordnum = tree_low_cst (CALL_EXPR_ARG (exp, 0), 0);
4318
4319           if (wordnum < 0 || wordnum >= nwords)
4320             error ("argument of %<__builtin_args_info%> out of range");
4321           else
4322             return GEN_INT (word_ptr[wordnum]);
4323         }
4324     }
4325   else
4326     error ("missing argument in %<__builtin_args_info%>");
4327
4328   return const0_rtx;
4329 }
4330
4331 /* Expand a call to __builtin_next_arg.  */
4332
4333 static rtx
4334 expand_builtin_next_arg (void)
4335 {
4336   /* Checking arguments is already done in fold_builtin_next_arg
4337      that must be called before this function.  */
4338   return expand_binop (ptr_mode, add_optab,
4339                        crtl->args.internal_arg_pointer,
4340                        crtl->args.arg_offset_rtx,
4341                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
4342 }
4343
4344 /* Make it easier for the backends by protecting the valist argument
4345    from multiple evaluations.  */
4346
4347 static tree
4348 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4349 {
4350   tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4351
4352   gcc_assert (vatype != NULL_TREE);
4353
4354   if (TREE_CODE (vatype) == ARRAY_TYPE)
4355     {
4356       if (TREE_SIDE_EFFECTS (valist))
4357         valist = save_expr (valist);
4358
4359       /* For this case, the backends will be expecting a pointer to
4360          vatype, but it's possible we've actually been given an array
4361          (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4362          So fix it.  */
4363       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4364         {
4365           tree p1 = build_pointer_type (TREE_TYPE (vatype));
4366           valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4367         }
4368     }
4369   else
4370     {
4371       tree pt;
4372
4373       if (! needs_lvalue)
4374         {
4375           if (! TREE_SIDE_EFFECTS (valist))
4376             return valist;
4377
4378           pt = build_pointer_type (vatype);
4379           valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4380           TREE_SIDE_EFFECTS (valist) = 1;
4381         }
4382
4383       if (TREE_SIDE_EFFECTS (valist))
4384         valist = save_expr (valist);
4385       valist = build_fold_indirect_ref_loc (loc, valist);
4386     }
4387
4388   return valist;
4389 }
4390
4391 /* The "standard" definition of va_list is void*.  */
4392
4393 tree
4394 std_build_builtin_va_list (void)
4395 {
4396   return ptr_type_node;
4397 }
4398
4399 /* The "standard" abi va_list is va_list_type_node.  */
4400
4401 tree
4402 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4403 {
4404   return va_list_type_node;
4405 }
4406
4407 /* The "standard" type of va_list is va_list_type_node.  */
4408
4409 tree
4410 std_canonical_va_list_type (tree type)
4411 {
4412   tree wtype, htype;
4413
4414   if (INDIRECT_REF_P (type))
4415     type = TREE_TYPE (type);
4416   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4417     type = TREE_TYPE (type);
4418   wtype = va_list_type_node;
4419   htype = type;
4420   /* Treat structure va_list types.  */
4421   if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4422     htype = TREE_TYPE (htype);
4423   else if (TREE_CODE (wtype) == ARRAY_TYPE)
4424     {
4425       /* If va_list is an array type, the argument may have decayed
4426          to a pointer type, e.g. by being passed to another function.
4427          In that case, unwrap both types so that we can compare the
4428          underlying records.  */
4429       if (TREE_CODE (htype) == ARRAY_TYPE
4430           || POINTER_TYPE_P (htype))
4431         {
4432           wtype = TREE_TYPE (wtype);
4433           htype = TREE_TYPE (htype);
4434         }
4435     }
4436   if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4437     return va_list_type_node;
4438
4439   return NULL_TREE;
4440 }
4441
4442 /* The "standard" implementation of va_start: just assign `nextarg' to
4443    the variable.  */
4444
4445 void
4446 std_expand_builtin_va_start (tree valist, rtx nextarg)
4447 {
4448   rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4449   convert_move (va_r, nextarg, 0);
4450 }
4451
4452 /* Expand EXP, a call to __builtin_va_start.  */
4453
4454 static rtx
4455 expand_builtin_va_start (tree exp)
4456 {
4457   rtx nextarg;
4458   tree valist;
4459   location_t loc = EXPR_LOCATION (exp);
4460
4461   if (call_expr_nargs (exp) < 2)
4462     {
4463       error_at (loc, "too few arguments to function %<va_start%>");
4464       return const0_rtx;
4465     }
4466
4467   if (fold_builtin_next_arg (exp, true))
4468     return const0_rtx;
4469
4470   nextarg = expand_builtin_next_arg ();
4471   valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4472
4473   if (targetm.expand_builtin_va_start)
4474     targetm.expand_builtin_va_start (valist, nextarg);
4475   else
4476     std_expand_builtin_va_start (valist, nextarg);
4477
4478   return const0_rtx;
4479 }
4480
4481 /* The "standard" implementation of va_arg: read the value from the
4482    current (padded) address and increment by the (padded) size.  */
4483
4484 tree
4485 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4486                           gimple_seq *post_p)
4487 {
4488   tree addr, t, type_size, rounded_size, valist_tmp;
4489   unsigned HOST_WIDE_INT align, boundary;
4490   bool indirect;
4491
4492 #ifdef ARGS_GROW_DOWNWARD
4493   /* All of the alignment and movement below is for args-grow-up machines.
4494      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4495      implement their own specialized gimplify_va_arg_expr routines.  */
4496   gcc_unreachable ();
4497 #endif
4498
4499   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4500   if (indirect)
4501     type = build_pointer_type (type);
4502
4503   align = PARM_BOUNDARY / BITS_PER_UNIT;
4504   boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
4505
4506   /* When we align parameter on stack for caller, if the parameter
4507      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4508      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
4509      here with caller.  */
4510   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4511     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4512
4513   boundary /= BITS_PER_UNIT;
4514
4515   /* Hoist the valist value into a temporary for the moment.  */
4516   valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4517
4518   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
4519      requires greater alignment, we must perform dynamic alignment.  */
4520   if (boundary > align
4521       && !integer_zerop (TYPE_SIZE (type)))
4522     {
4523       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4524                   fold_build2 (POINTER_PLUS_EXPR,
4525                                TREE_TYPE (valist),
4526                                valist_tmp, size_int (boundary - 1)));
4527       gimplify_and_add (t, pre_p);
4528
4529       t = fold_convert (sizetype, valist_tmp);
4530       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4531                   fold_convert (TREE_TYPE (valist),
4532                                 fold_build2 (BIT_AND_EXPR, sizetype, t,
4533                                              size_int (-boundary))));
4534       gimplify_and_add (t, pre_p);
4535     }
4536   else
4537     boundary = align;
4538
4539   /* If the actual alignment is less than the alignment of the type,
4540      adjust the type accordingly so that we don't assume strict alignment
4541      when dereferencing the pointer.  */
4542   boundary *= BITS_PER_UNIT;
4543   if (boundary < TYPE_ALIGN (type))
4544     {
4545       type = build_variant_type_copy (type);
4546       TYPE_ALIGN (type) = boundary;
4547     }
4548
4549   /* Compute the rounded size of the type.  */
4550   type_size = size_in_bytes (type);
4551   rounded_size = round_up (type_size, align);
4552
4553   /* Reduce rounded_size so it's sharable with the postqueue.  */
4554   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4555
4556   /* Get AP.  */
4557   addr = valist_tmp;
4558   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4559     {
4560       /* Small args are padded downward.  */
4561       t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4562                        rounded_size, size_int (align));
4563       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4564                        size_binop (MINUS_EXPR, rounded_size, type_size));
4565       addr = fold_build2 (POINTER_PLUS_EXPR,
4566                           TREE_TYPE (addr), addr, t);
4567     }
4568
4569   /* Compute new value for AP.  */
4570   t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist), valist_tmp, rounded_size);
4571   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4572   gimplify_and_add (t, pre_p);
4573
4574   addr = fold_convert (build_pointer_type (type), addr);
4575
4576   if (indirect)
4577     addr = build_va_arg_indirect_ref (addr);
4578
4579   return build_va_arg_indirect_ref (addr);
4580 }
4581
4582 /* Build an indirect-ref expression over the given TREE, which represents a
4583    piece of a va_arg() expansion.  */
4584 tree
4585 build_va_arg_indirect_ref (tree addr)
4586 {
4587   addr = build_fold_indirect_ref_loc (EXPR_LOCATION (addr), addr);
4588
4589   if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF.  */
4590     mf_mark (addr);
4591
4592   return addr;
4593 }
4594
4595 /* Return a dummy expression of type TYPE in order to keep going after an
4596    error.  */
4597
4598 static tree
4599 dummy_object (tree type)
4600 {
4601   tree t = build_int_cst (build_pointer_type (type), 0);
4602   return build1 (INDIRECT_REF, type, t);
4603 }
4604
4605 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4606    builtin function, but a very special sort of operator.  */
4607
4608 enum gimplify_status
4609 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4610 {
4611   tree promoted_type, have_va_type;
4612   tree valist = TREE_OPERAND (*expr_p, 0);
4613   tree type = TREE_TYPE (*expr_p);
4614   tree t;
4615   location_t loc = EXPR_LOCATION (*expr_p);
4616
4617   /* Verify that valist is of the proper type.  */
4618   have_va_type = TREE_TYPE (valist);
4619   if (have_va_type == error_mark_node)
4620     return GS_ERROR;
4621   have_va_type = targetm.canonical_va_list_type (have_va_type);
4622
4623   if (have_va_type == NULL_TREE)
4624     {
4625       error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4626       return GS_ERROR;
4627     }
4628
4629   /* Generate a diagnostic for requesting data of a type that cannot
4630      be passed through `...' due to type promotion at the call site.  */
4631   if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4632            != type)
4633     {
4634       static bool gave_help;
4635       bool warned;
4636
4637       /* Unfortunately, this is merely undefined, rather than a constraint
4638          violation, so we cannot make this an error.  If this call is never
4639          executed, the program is still strictly conforming.  */
4640       warned = warning_at (loc, 0,
4641                            "%qT is promoted to %qT when passed through %<...%>",
4642                            type, promoted_type);
4643       if (!gave_help && warned)
4644         {
4645           gave_help = true;
4646           inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4647                   promoted_type, type);
4648         }
4649
4650       /* We can, however, treat "undefined" any way we please.
4651          Call abort to encourage the user to fix the program.  */
4652       if (warned)
4653         inform (loc, "if this code is reached, the program will abort");
4654       /* Before the abort, allow the evaluation of the va_list
4655          expression to exit or longjmp.  */
4656       gimplify_and_add (valist, pre_p);
4657       t = build_call_expr_loc (loc,
4658                                implicit_built_in_decls[BUILT_IN_TRAP], 0);
4659       gimplify_and_add (t, pre_p);
4660
4661       /* This is dead code, but go ahead and finish so that the
4662          mode of the result comes out right.  */
4663       *expr_p = dummy_object (type);
4664       return GS_ALL_DONE;
4665     }
4666   else
4667     {
4668       /* Make it easier for the backends by protecting the valist argument
4669          from multiple evaluations.  */
4670       if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4671         {
4672           /* For this case, the backends will be expecting a pointer to
4673              TREE_TYPE (abi), but it's possible we've
4674              actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4675              So fix it.  */
4676           if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4677             {
4678               tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4679               valist = fold_convert_loc (loc, p1,
4680                                          build_fold_addr_expr_loc (loc, valist));
4681             }
4682
4683           gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4684         }
4685       else
4686         gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4687
4688       if (!targetm.gimplify_va_arg_expr)
4689         /* FIXME: Once most targets are converted we should merely
4690            assert this is non-null.  */
4691         return GS_ALL_DONE;
4692
4693       *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4694       return GS_OK;
4695     }
4696 }
4697
4698 /* Expand EXP, a call to __builtin_va_end.  */
4699
4700 static rtx
4701 expand_builtin_va_end (tree exp)
4702 {
4703   tree valist = CALL_EXPR_ARG (exp, 0);
4704
4705   /* Evaluate for side effects, if needed.  I hate macros that don't
4706      do that.  */
4707   if (TREE_SIDE_EFFECTS (valist))
4708     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4709
4710   return const0_rtx;
4711 }
4712
4713 /* Expand EXP, a call to __builtin_va_copy.  We do this as a
4714    builtin rather than just as an assignment in stdarg.h because of the
4715    nastiness of array-type va_list types.  */
4716
4717 static rtx
4718 expand_builtin_va_copy (tree exp)
4719 {
4720   tree dst, src, t;
4721   location_t loc = EXPR_LOCATION (exp);
4722
4723   dst = CALL_EXPR_ARG (exp, 0);
4724   src = CALL_EXPR_ARG (exp, 1);
4725
4726   dst = stabilize_va_list_loc (loc, dst, 1);
4727   src = stabilize_va_list_loc (loc, src, 0);
4728
4729   gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4730
4731   if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4732     {
4733       t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4734       TREE_SIDE_EFFECTS (t) = 1;
4735       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4736     }
4737   else
4738     {
4739       rtx dstb, srcb, size;
4740
4741       /* Evaluate to pointers.  */
4742       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4743       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4744       size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4745                   NULL_RTX, VOIDmode, EXPAND_NORMAL);
4746
4747       dstb = convert_memory_address (Pmode, dstb);
4748       srcb = convert_memory_address (Pmode, srcb);
4749
4750       /* "Dereference" to BLKmode memories.  */
4751       dstb = gen_rtx_MEM (BLKmode, dstb);
4752       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4753       set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4754       srcb = gen_rtx_MEM (BLKmode, srcb);
4755       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4756       set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4757
4758       /* Copy.  */
4759       emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4760     }
4761
4762   return const0_rtx;
4763 }
4764
4765 /* Expand a call to one of the builtin functions __builtin_frame_address or
4766    __builtin_return_address.  */
4767
4768 static rtx
4769 expand_builtin_frame_address (tree fndecl, tree exp)
4770 {
4771   /* The argument must be a nonnegative integer constant.
4772      It counts the number of frames to scan up the stack.
4773      The value is the return address saved in that frame.  */
4774   if (call_expr_nargs (exp) == 0)
4775     /* Warning about missing arg was already issued.  */
4776     return const0_rtx;
4777   else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4778     {
4779       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4780         error ("invalid argument to %<__builtin_frame_address%>");
4781       else
4782         error ("invalid argument to %<__builtin_return_address%>");
4783       return const0_rtx;
4784     }
4785   else
4786     {
4787       rtx tem
4788         = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4789                                       tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4790
4791       /* Some ports cannot access arbitrary stack frames.  */
4792       if (tem == NULL)
4793         {
4794           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4795             warning (0, "unsupported argument to %<__builtin_frame_address%>");
4796           else
4797             warning (0, "unsupported argument to %<__builtin_return_address%>");
4798           return const0_rtx;
4799         }
4800
4801       /* For __builtin_frame_address, return what we've got.  */
4802       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4803         return tem;
4804
4805       if (!REG_P (tem)
4806           && ! CONSTANT_P (tem))
4807         tem = copy_to_mode_reg (Pmode, tem);
4808       return tem;
4809     }
4810 }
4811
4812 /* Expand EXP, a call to the alloca builtin.  Return NULL_RTX if
4813    we failed and the caller should emit a normal call, otherwise try to get
4814    the result in TARGET, if convenient.  */
4815
4816 static rtx
4817 expand_builtin_alloca (tree exp, rtx target)
4818 {
4819   rtx op0;
4820   rtx result;
4821
4822   /* Emit normal call if marked not-inlineable.  */
4823   if (CALL_CANNOT_INLINE_P (exp))
4824     return NULL_RTX;
4825
4826   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4827     return NULL_RTX;
4828
4829   /* Compute the argument.  */
4830   op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4831
4832   /* Allocate the desired space.  */
4833   result = allocate_dynamic_stack_space (op0, target, BITS_PER_UNIT);
4834   result = convert_memory_address (ptr_mode, result);
4835
4836   return result;
4837 }
4838
4839 /* Expand a call to a bswap builtin with argument ARG0.  MODE
4840    is the mode to expand with.  */
4841
4842 static rtx
4843 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
4844 {
4845   enum machine_mode mode;
4846   tree arg;
4847   rtx op0;
4848
4849   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4850     return NULL_RTX;
4851
4852   arg = CALL_EXPR_ARG (exp, 0);
4853   mode = TYPE_MODE (TREE_TYPE (arg));
4854   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4855
4856   target = expand_unop (mode, bswap_optab, op0, target, 1);
4857
4858   gcc_assert (target);
4859
4860   return convert_to_mode (mode, target, 0);
4861 }
4862
4863 /* Expand a call to a unary builtin in EXP.
4864    Return NULL_RTX if a normal call should be emitted rather than expanding the
4865    function in-line.  If convenient, the result should be placed in TARGET.
4866    SUBTARGET may be used as the target for computing one of EXP's operands.  */
4867
4868 static rtx
4869 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
4870                      rtx subtarget, optab op_optab)
4871 {
4872   rtx op0;
4873
4874   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4875     return NULL_RTX;
4876
4877   /* Compute the argument.  */
4878   op0 = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
4879                      VOIDmode, EXPAND_NORMAL);
4880   /* Compute op, into TARGET if possible.
4881      Set TARGET to wherever the result comes back.  */
4882   target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
4883                         op_optab, op0, target, 1);
4884   gcc_assert (target);
4885
4886   return convert_to_mode (target_mode, target, 0);
4887 }
4888
4889 /* Expand a call to __builtin_expect.  We just return our argument
4890    as the builtin_expect semantic should've been already executed by
4891    tree branch prediction pass. */
4892
4893 static rtx
4894 expand_builtin_expect (tree exp, rtx target)
4895 {
4896   tree arg, c;
4897
4898   if (call_expr_nargs (exp) < 2)
4899     return const0_rtx;
4900   arg = CALL_EXPR_ARG (exp, 0);
4901   c = CALL_EXPR_ARG (exp, 1);
4902
4903   target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4904   /* When guessing was done, the hints should be already stripped away.  */
4905   gcc_assert (!flag_guess_branch_prob
4906               || optimize == 0 || errorcount || sorrycount);
4907   return target;
4908 }
4909
4910 void
4911 expand_builtin_trap (void)
4912 {
4913 #ifdef HAVE_trap
4914   if (HAVE_trap)
4915     emit_insn (gen_trap ());
4916   else
4917 #endif
4918     emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4919   emit_barrier ();
4920 }
4921
4922 /* Expand a call to __builtin_unreachable.  We do nothing except emit
4923    a barrier saying that control flow will not pass here.
4924
4925    It is the responsibility of the program being compiled to ensure
4926    that control flow does never reach __builtin_unreachable.  */
4927 static void
4928 expand_builtin_unreachable (void)
4929 {
4930   emit_barrier ();
4931 }
4932
4933 /* Expand EXP, a call to fabs, fabsf or fabsl.
4934    Return NULL_RTX if a normal call should be emitted rather than expanding
4935    the function inline.  If convenient, the result should be placed
4936    in TARGET.  SUBTARGET may be used as the target for computing
4937    the operand.  */
4938
4939 static rtx
4940 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
4941 {
4942   enum machine_mode mode;
4943   tree arg;
4944   rtx op0;
4945
4946   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4947     return NULL_RTX;
4948
4949   arg = CALL_EXPR_ARG (exp, 0);
4950   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
4951   mode = TYPE_MODE (TREE_TYPE (arg));
4952   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4953   return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4954 }
4955
4956 /* Expand EXP, a call to copysign, copysignf, or copysignl.
4957    Return NULL is a normal call should be emitted rather than expanding the
4958    function inline.  If convenient, the result should be placed in TARGET.
4959    SUBTARGET may be used as the target for computing the operand.  */
4960
4961 static rtx
4962 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
4963 {
4964   rtx op0, op1;
4965   tree arg;
4966
4967   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
4968     return NULL_RTX;
4969
4970   arg = CALL_EXPR_ARG (exp, 0);
4971   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4972
4973   arg = CALL_EXPR_ARG (exp, 1);
4974   op1 = expand_normal (arg);
4975
4976   return expand_copysign (op0, op1, target);
4977 }
4978
4979 /* Create a new constant string literal and return a char* pointer to it.
4980    The STRING_CST value is the LEN characters at STR.  */
4981 tree
4982 build_string_literal (int len, const char *str)
4983 {
4984   tree t, elem, index, type;
4985
4986   t = build_string (len, str);
4987   elem = build_type_variant (char_type_node, 1, 0);
4988   index = build_index_type (size_int (len - 1));
4989   type = build_array_type (elem, index);
4990   TREE_TYPE (t) = type;
4991   TREE_CONSTANT (t) = 1;
4992   TREE_READONLY (t) = 1;
4993   TREE_STATIC (t) = 1;
4994
4995   type = build_pointer_type (elem);
4996   t = build1 (ADDR_EXPR, type,
4997               build4 (ARRAY_REF, elem,
4998                       t, integer_zero_node, NULL_TREE, NULL_TREE));
4999   return t;
5000 }
5001
5002 /* Expand EXP, a call to printf or printf_unlocked.
5003    Return NULL_RTX if a normal call should be emitted rather than transforming
5004    the function inline.  If convenient, the result should be placed in
5005    TARGET with mode MODE.  UNLOCKED indicates this is a printf_unlocked
5006    call.  */
5007 static rtx
5008 expand_builtin_printf (tree exp, rtx target, enum machine_mode mode,
5009                        bool unlocked)
5010 {
5011   /* If we're using an unlocked function, assume the other unlocked
5012      functions exist explicitly.  */
5013   tree const fn_putchar = unlocked ? built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED]
5014     : implicit_built_in_decls[BUILT_IN_PUTCHAR];
5015   tree const fn_puts = unlocked ? built_in_decls[BUILT_IN_PUTS_UNLOCKED]
5016     : implicit_built_in_decls[BUILT_IN_PUTS];
5017   const char *fmt_str;
5018   tree fn = 0;
5019   tree fmt, arg;
5020   int nargs = call_expr_nargs (exp);
5021
5022   /* If the return value is used, don't do the transformation.  */
5023   if (target != const0_rtx)
5024     return NULL_RTX;
5025
5026   /* Verify the required arguments in the original call.  */
5027   if (nargs == 0)
5028     return NULL_RTX;
5029   fmt = CALL_EXPR_ARG (exp, 0);
5030   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5031     return NULL_RTX;
5032
5033   /* Check whether the format is a literal string constant.  */
5034   fmt_str = c_getstr (fmt);
5035   if (fmt_str == NULL)
5036     return NULL_RTX;
5037
5038   if (!init_target_chars ())
5039     return NULL_RTX;
5040
5041   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
5042   if (strcmp (fmt_str, target_percent_s_newline) == 0)
5043     {
5044       if ((nargs != 2)
5045           || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 1))))
5046         return NULL_RTX;
5047       if (fn_puts)
5048         fn = build_call_nofold (fn_puts, 1, CALL_EXPR_ARG (exp, 1));
5049     }
5050   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
5051   else if (strcmp (fmt_str, target_percent_c) == 0)
5052     {
5053       if ((nargs != 2)
5054           || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1))) != INTEGER_TYPE)
5055         return NULL_RTX;
5056       if (fn_putchar)
5057         fn = build_call_nofold (fn_putchar, 1, CALL_EXPR_ARG (exp, 1));
5058     }
5059   else
5060     {
5061       /* We can't handle anything else with % args or %% ... yet.  */
5062       if (strchr (fmt_str, target_percent))
5063         return NULL_RTX;
5064
5065       if (nargs > 1)
5066         return NULL_RTX;
5067
5068       /* If the format specifier was "", printf does nothing.  */
5069       if (fmt_str[0] == '\0')
5070         return const0_rtx;
5071       /* If the format specifier has length of 1, call putchar.  */
5072       if (fmt_str[1] == '\0')
5073         {
5074           /* Given printf("c"), (where c is any one character,)
5075              convert "c"[0] to an int and pass that to the replacement
5076              function.  */
5077           arg = build_int_cst (NULL_TREE, fmt_str[0]);
5078           if (fn_putchar)
5079             fn = build_call_nofold (fn_putchar, 1, arg);
5080         }
5081       else
5082         {
5083           /* If the format specifier was "string\n", call puts("string").  */
5084           size_t len = strlen (fmt_str);
5085           if ((unsigned char)fmt_str[len - 1] == target_newline)
5086             {
5087               /* Create a NUL-terminated string that's one char shorter
5088                  than the original, stripping off the trailing '\n'.  */
5089               char *newstr = XALLOCAVEC (char, len);
5090               memcpy (newstr, fmt_str, len - 1);
5091               newstr[len - 1] = 0;
5092               arg = build_string_literal (len, newstr);
5093               if (fn_puts)
5094                 fn = build_call_nofold (fn_puts, 1, arg);
5095             }
5096           else
5097             /* We'd like to arrange to call fputs(string,stdout) here,
5098                but we need stdout and don't have a way to get it yet.  */
5099             return NULL_RTX;
5100         }
5101     }
5102
5103   if (!fn)
5104     return NULL_RTX;
5105   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
5106   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5107   return expand_expr (fn, target, mode, EXPAND_NORMAL);
5108 }
5109
5110 /* Expand EXP, a call to fprintf or fprintf_unlocked.
5111    Return NULL_RTX if a normal call should be emitted rather than transforming
5112    the function inline.  If convenient, the result should be placed in
5113    TARGET with mode MODE.  UNLOCKED indicates this is a fprintf_unlocked
5114    call.  */
5115 static rtx
5116 expand_builtin_fprintf (tree exp, rtx target, enum machine_mode mode,
5117                         bool unlocked)
5118 {
5119   /* If we're using an unlocked function, assume the other unlocked
5120      functions exist explicitly.  */
5121   tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
5122     : implicit_built_in_decls[BUILT_IN_FPUTC];
5123   tree const fn_fputs = unlocked ? built_in_decls[BUILT_IN_FPUTS_UNLOCKED]
5124     : implicit_built_in_decls[BUILT_IN_FPUTS];
5125   const char *fmt_str;
5126   tree fn = 0;
5127   tree fmt, fp, arg;
5128   int nargs = call_expr_nargs (exp);
5129
5130   /* If the return value is used, don't do the transformation.  */
5131   if (target != const0_rtx)
5132     return NULL_RTX;
5133
5134   /* Verify the required arguments in the original call.  */
5135   if (nargs < 2)
5136     return NULL_RTX;
5137   fp = CALL_EXPR_ARG (exp, 0);
5138   if (! POINTER_TYPE_P (TREE_TYPE (fp)))
5139     return NULL_RTX;
5140   fmt = CALL_EXPR_ARG (exp, 1);
5141   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5142     return NULL_RTX;
5143
5144   /* Check whether the format is a literal string constant.  */
5145   fmt_str = c_getstr (fmt);
5146   if (fmt_str == NULL)
5147     return NULL_RTX;
5148
5149   if (!init_target_chars ())
5150     return NULL_RTX;
5151
5152   /* If the format specifier was "%s", call __builtin_fputs(arg,fp).  */
5153   if (strcmp (fmt_str, target_percent_s) == 0)
5154     {
5155       if ((nargs != 3)
5156           || ! POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_ARG (exp, 2))))
5157         return NULL_RTX;
5158       arg = CALL_EXPR_ARG (exp, 2);
5159       if (fn_fputs)
5160         fn = build_call_nofold (fn_fputs, 2, arg, fp);
5161     }
5162   /* If the format specifier was "%c", call __builtin_fputc(arg,fp).  */
5163   else if (strcmp (fmt_str, target_percent_c) == 0)
5164     {
5165       if ((nargs != 3)
5166           || TREE_CODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2))) != INTEGER_TYPE)
5167         return NULL_RTX;
5168       arg = CALL_EXPR_ARG (exp, 2);
5169       if (fn_fputc)
5170         fn = build_call_nofold (fn_fputc, 2, arg, fp);
5171     }
5172   else
5173     {
5174       /* We can't handle anything else with % args or %% ... yet.  */
5175       if (strchr (fmt_str, target_percent))
5176         return NULL_RTX;
5177
5178       if (nargs > 2)
5179         return NULL_RTX;
5180
5181       /* If the format specifier was "", fprintf does nothing.  */
5182       if (fmt_str[0] == '\0')
5183         {
5184           /* Evaluate and ignore FILE* argument for side-effects.  */
5185           expand_expr (fp, const0_rtx, VOIDmode, EXPAND_NORMAL);
5186           return const0_rtx;
5187         }
5188
5189       /* When "string" doesn't contain %, replace all cases of
5190          fprintf(stream,string) with fputs(string,stream).  The fputs
5191          builtin will take care of special cases like length == 1.  */
5192       if (fn_fputs)
5193         fn = build_call_nofold (fn_fputs, 2, fmt, fp);
5194     }
5195
5196   if (!fn)
5197     return NULL_RTX;
5198   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
5199   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
5200   return expand_expr (fn, target, mode, EXPAND_NORMAL);
5201 }
5202
5203 /* Expand a call EXP to sprintf.  Return NULL_RTX if
5204    a normal call should be emitted rather than expanding the function
5205    inline.  If convenient, the result should be placed in TARGET with
5206    mode MODE.  */
5207
5208 static rtx
5209 expand_builtin_sprintf (tree exp, rtx target, enum machine_mode mode)
5210 {
5211   tree dest, fmt;
5212   const char *fmt_str;
5213   int nargs = call_expr_nargs (exp);
5214
5215   /* Verify the required arguments in the original call.  */
5216   if (nargs < 2)
5217     return NULL_RTX;
5218   dest = CALL_EXPR_ARG (exp, 0);
5219   if (! POINTER_TYPE_P (TREE_TYPE (dest)))
5220     return NULL_RTX;
5221   fmt = CALL_EXPR_ARG (exp, 0);
5222   if (! POINTER_TYPE_P (TREE_TYPE (fmt)))
5223     return NULL_RTX;
5224
5225   /* Check whether the format is a literal string constant.  */
5226   fmt_str = c_getstr (fmt);
5227   if (fmt_str == NULL)
5228     return NULL_RTX;
5229
5230   if (!init_target_chars ())
5231     return NULL_RTX;
5232
5233   /* If the format doesn't contain % args or %%, use strcpy.  */
5234   if (strchr (fmt_str, target_percent) == 0)
5235     {
5236       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5237       tree exp;
5238
5239       if ((nargs > 2) || ! fn)
5240         return NULL_RTX;
5241       expand_expr (build_call_nofold (fn, 2, dest, fmt),
5242                    const0_rtx, VOIDmode, EXPAND_NORMAL);
5243       if (target == const0_rtx)
5244         return const0_rtx;
5245       exp = build_int_cst (NULL_TREE, strlen (fmt_str));
5246       return expand_expr (exp, target, mode, EXPAND_NORMAL);
5247     }
5248   /* If the format is "%s", use strcpy if the result isn't used.  */
5249   else if (strcmp (fmt_str, target_percent_s) == 0)
5250     {
5251       tree fn, arg, len;
5252       fn = implicit_built_in_decls[BUILT_IN_STRCPY];
5253
5254       if (! fn)
5255         return NULL_RTX;
5256       if (nargs != 3)
5257         return NULL_RTX;
5258       arg = CALL_EXPR_ARG (exp, 2);
5259       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
5260         return NULL_RTX;
5261
5262       if (target != const0_rtx)
5263         {
5264           len = c_strlen (arg, 1);
5265           if (! len || TREE_CODE (len) != INTEGER_CST)
5266             return NULL_RTX;
5267         }
5268       else
5269         len = NULL_TREE;
5270
5271       expand_expr (build_call_nofold (fn, 2, dest, arg),
5272                    const0_rtx, VOIDmode, EXPAND_NORMAL);
5273
5274       if (target == const0_rtx)
5275         return const0_rtx;
5276       return expand_expr (len, target, mode, EXPAND_NORMAL);
5277     }
5278
5279   return NULL_RTX;
5280 }
5281
5282 /* Expand a call to either the entry or exit function profiler.  */
5283
5284 static rtx
5285 expand_builtin_profile_func (bool exitp)
5286 {
5287   rtx this_rtx, which;
5288
5289   this_rtx = DECL_RTL (current_function_decl);
5290   gcc_assert (MEM_P (this_rtx));
5291   this_rtx = XEXP (this_rtx, 0);
5292
5293   if (exitp)
5294     which = profile_function_exit_libfunc;
5295   else
5296     which = profile_function_entry_libfunc;
5297
5298   emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this_rtx, Pmode,
5299                      expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5300                                                  0),
5301                      Pmode);
5302
5303   return const0_rtx;
5304 }
5305
5306 /* Expand a call to __builtin___clear_cache.  */
5307
5308 static rtx
5309 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
5310 {
5311 #ifndef HAVE_clear_cache
5312 #ifdef CLEAR_INSN_CACHE
5313   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5314      does something.  Just do the default expansion to a call to
5315      __clear_cache().  */
5316   return NULL_RTX;
5317 #else
5318   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5319      does nothing.  There is no need to call it.  Do nothing.  */
5320   return const0_rtx;
5321 #endif /* CLEAR_INSN_CACHE */
5322 #else
5323   /* We have a "clear_cache" insn, and it will handle everything.  */
5324   tree begin, end;
5325   rtx begin_rtx, end_rtx;
5326   enum insn_code icode;
5327
5328   /* We must not expand to a library call.  If we did, any
5329      fallback library function in libgcc that might contain a call to
5330      __builtin___clear_cache() would recurse infinitely.  */
5331   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5332     {
5333       error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5334       return const0_rtx;
5335     }
5336
5337   if (HAVE_clear_cache)
5338     {
5339       icode = CODE_FOR_clear_cache;
5340
5341       begin = CALL_EXPR_ARG (exp, 0);
5342       begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
5343       begin_rtx = convert_memory_address (Pmode, begin_rtx);
5344       if (!insn_data[icode].operand[0].predicate (begin_rtx, Pmode))
5345         begin_rtx = copy_to_mode_reg (Pmode, begin_rtx);
5346
5347       end = CALL_EXPR_ARG (exp, 1);
5348       end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
5349       end_rtx = convert_memory_address (Pmode, end_rtx);
5350       if (!insn_data[icode].operand[1].predicate (end_rtx, Pmode))
5351         end_rtx = copy_to_mode_reg (Pmode, end_rtx);
5352
5353       emit_insn (gen_clear_cache (begin_rtx, end_rtx));
5354     }
5355   return const0_rtx;
5356 #endif /* HAVE_clear_cache */
5357 }
5358
5359 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT.  */
5360
5361 static rtx
5362 round_trampoline_addr (rtx tramp)
5363 {
5364   rtx temp, addend, mask;
5365
5366   /* If we don't need too much alignment, we'll have been guaranteed
5367      proper alignment by get_trampoline_type.  */
5368   if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5369     return tramp;
5370
5371   /* Round address up to desired boundary.  */
5372   temp = gen_reg_rtx (Pmode);
5373   addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5374   mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5375
5376   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5377                                temp, 0, OPTAB_LIB_WIDEN);
5378   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5379                                temp, 0, OPTAB_LIB_WIDEN);
5380
5381   return tramp;
5382 }
5383
5384 static rtx
5385 expand_builtin_init_trampoline (tree exp)
5386 {
5387   tree t_tramp, t_func, t_chain;
5388   rtx m_tramp, r_tramp, r_chain, tmp;
5389
5390   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5391                          POINTER_TYPE, VOID_TYPE))
5392     return NULL_RTX;
5393
5394   t_tramp = CALL_EXPR_ARG (exp, 0);
5395   t_func = CALL_EXPR_ARG (exp, 1);
5396   t_chain = CALL_EXPR_ARG (exp, 2);
5397
5398   r_tramp = expand_normal (t_tramp);
5399   m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
5400   MEM_NOTRAP_P (m_tramp) = 1;
5401
5402   /* The TRAMP argument should be the address of a field within the
5403      local function's FRAME decl.  Let's see if we can fill in the
5404      to fill in the MEM_ATTRs for this memory.  */
5405   if (TREE_CODE (t_tramp) == ADDR_EXPR)
5406     set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
5407                                      true, 0);
5408
5409   tmp = round_trampoline_addr (r_tramp);
5410   if (tmp != r_tramp)
5411     {
5412       m_tramp = change_address (m_tramp, BLKmode, tmp);
5413       set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
5414       set_mem_size (m_tramp, GEN_INT (TRAMPOLINE_SIZE));
5415     }
5416
5417   /* The FUNC argument should be the address of the nested function.
5418      Extract the actual function decl to pass to the hook.  */
5419   gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
5420   t_func = TREE_OPERAND (t_func, 0);
5421   gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
5422
5423   r_chain = expand_normal (t_chain);
5424
5425   /* Generate insns to initialize the trampoline.  */
5426   targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
5427
5428   trampolines_created = 1;
5429   return const0_rtx;
5430 }
5431
5432 static rtx
5433 expand_builtin_adjust_trampoline (tree exp)
5434 {
5435   rtx tramp;
5436
5437   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5438     return NULL_RTX;
5439
5440   tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5441   tramp = round_trampoline_addr (tramp);
5442   if (targetm.calls.trampoline_adjust_address)
5443     tramp = targetm.calls.trampoline_adjust_address (tramp);
5444
5445   return tramp;
5446 }
5447
5448 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5449    function.  The function first checks whether the back end provides
5450    an insn to implement signbit for the respective mode.  If not, it
5451    checks whether the floating point format of the value is such that
5452    the sign bit can be extracted.  If that is not the case, the
5453    function returns NULL_RTX to indicate that a normal call should be
5454    emitted rather than expanding the function in-line.  EXP is the
5455    expression that is a call to the builtin function; if convenient,
5456    the result should be placed in TARGET.  */
5457 static rtx
5458 expand_builtin_signbit (tree exp, rtx target)
5459 {
5460   const struct real_format *fmt;
5461   enum machine_mode fmode, imode, rmode;
5462   HOST_WIDE_INT hi, lo;
5463   tree arg;
5464   int word, bitpos;
5465   enum insn_code icode;
5466   rtx temp;
5467   location_t loc = EXPR_LOCATION (exp);
5468
5469   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5470     return NULL_RTX;
5471
5472   arg = CALL_EXPR_ARG (exp, 0);
5473   fmode = TYPE_MODE (TREE_TYPE (arg));
5474   rmode = TYPE_MODE (TREE_TYPE (exp));
5475   fmt = REAL_MODE_FORMAT (fmode);
5476
5477   arg = builtin_save_expr (arg);
5478
5479   /* Expand the argument yielding a RTX expression. */
5480   temp = expand_normal (arg);
5481
5482   /* Check if the back end provides an insn that handles signbit for the
5483      argument's mode. */
5484   icode = signbit_optab->handlers [(int) fmode].insn_code;
5485   if (icode != CODE_FOR_nothing)
5486     {
5487       target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5488       emit_unop_insn (icode, target, temp, UNKNOWN);
5489       return target;
5490     }
5491
5492   /* For floating point formats without a sign bit, implement signbit
5493      as "ARG < 0.0".  */
5494   bitpos = fmt->signbit_ro;
5495   if (bitpos < 0)
5496   {
5497     /* But we can't do this if the format supports signed zero.  */
5498     if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5499       return NULL_RTX;
5500
5501     arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5502                        build_real (TREE_TYPE (arg), dconst0));
5503     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5504   }
5505
5506   if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5507     {
5508       imode = int_mode_for_mode (fmode);
5509       if (imode == BLKmode)
5510         return NULL_RTX;
5511       temp = gen_lowpart (imode, temp);
5512     }
5513   else
5514     {
5515       imode = word_mode;
5516       /* Handle targets with different FP word orders.  */
5517       if (FLOAT_WORDS_BIG_ENDIAN)
5518         word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5519       else
5520         word = bitpos / BITS_PER_WORD;
5521       temp = operand_subword_force (temp, word, fmode);
5522       bitpos = bitpos % BITS_PER_WORD;
5523     }
5524
5525   /* Force the intermediate word_mode (or narrower) result into a
5526      register.  This avoids attempting to create paradoxical SUBREGs
5527      of floating point modes below.  */
5528   temp = force_reg (imode, temp);
5529
5530   /* If the bitpos is within the "result mode" lowpart, the operation
5531      can be implement with a single bitwise AND.  Otherwise, we need
5532      a right shift and an AND.  */
5533
5534   if (bitpos < GET_MODE_BITSIZE (rmode))
5535     {
5536       if (bitpos < HOST_BITS_PER_WIDE_INT)
5537         {
5538           hi = 0;
5539           lo = (HOST_WIDE_INT) 1 << bitpos;
5540         }
5541       else
5542         {
5543           hi = (HOST_WIDE_INT) 1 << (bitpos - HOST_BITS_PER_WIDE_INT);
5544           lo = 0;
5545         }
5546
5547       if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5548         temp = gen_lowpart (rmode, temp);
5549       temp = expand_binop (rmode, and_optab, temp,
5550                            immed_double_const (lo, hi, rmode),
5551                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5552     }
5553   else
5554     {
5555       /* Perform a logical right shift to place the signbit in the least
5556          significant bit, then truncate the result to the desired mode
5557          and mask just this bit.  */
5558       temp = expand_shift (RSHIFT_EXPR, imode, temp,
5559                            build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5560       temp = gen_lowpart (rmode, temp);
5561       temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5562                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5563     }
5564
5565   return temp;
5566 }
5567
5568 /* Expand fork or exec calls.  TARGET is the desired target of the
5569    call.  EXP is the call. FN is the
5570    identificator of the actual function.  IGNORE is nonzero if the
5571    value is to be ignored.  */
5572
5573 static rtx
5574 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5575 {
5576   tree id, decl;
5577   tree call;
5578
5579   /* If we are not profiling, just call the function.  */
5580   if (!profile_arc_flag)
5581     return NULL_RTX;
5582
5583   /* Otherwise call the wrapper.  This should be equivalent for the rest of
5584      compiler, so the code does not diverge, and the wrapper may run the
5585      code necessary for keeping the profiling sane.  */
5586
5587   switch (DECL_FUNCTION_CODE (fn))
5588     {
5589     case BUILT_IN_FORK:
5590       id = get_identifier ("__gcov_fork");
5591       break;
5592
5593     case BUILT_IN_EXECL:
5594       id = get_identifier ("__gcov_execl");
5595       break;
5596
5597     case BUILT_IN_EXECV:
5598       id = get_identifier ("__gcov_execv");
5599       break;
5600
5601     case BUILT_IN_EXECLP:
5602       id = get_identifier ("__gcov_execlp");
5603       break;
5604
5605     case BUILT_IN_EXECLE:
5606       id = get_identifier ("__gcov_execle");
5607       break;
5608
5609     case BUILT_IN_EXECVP:
5610       id = get_identifier ("__gcov_execvp");
5611       break;
5612
5613     case BUILT_IN_EXECVE:
5614       id = get_identifier ("__gcov_execve");
5615       break;
5616
5617     default:
5618       gcc_unreachable ();
5619     }
5620
5621   decl = build_decl (DECL_SOURCE_LOCATION (fn),
5622                      FUNCTION_DECL, id, TREE_TYPE (fn));
5623   DECL_EXTERNAL (decl) = 1;
5624   TREE_PUBLIC (decl) = 1;
5625   DECL_ARTIFICIAL (decl) = 1;
5626   TREE_NOTHROW (decl) = 1;
5627   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5628   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5629   call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5630   return expand_call (call, target, ignore);
5631  }
5632
5633
5634 \f
5635 /* Reconstitute a mode for a __sync intrinsic operation.  Since the type of
5636    the pointer in these functions is void*, the tree optimizers may remove
5637    casts.  The mode computed in expand_builtin isn't reliable either, due
5638    to __sync_bool_compare_and_swap.
5639
5640    FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5641    group of builtins.  This gives us log2 of the mode size.  */
5642
5643 static inline enum machine_mode
5644 get_builtin_sync_mode (int fcode_diff)
5645 {
5646   /* The size is not negotiable, so ask not to get BLKmode in return
5647      if the target indicates that a smaller size would be better.  */
5648   return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5649 }
5650
5651 /* Expand the memory expression LOC and return the appropriate memory operand
5652    for the builtin_sync operations.  */
5653
5654 static rtx
5655 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5656 {
5657   rtx addr, mem;
5658
5659   addr = expand_expr (loc, NULL_RTX, Pmode, EXPAND_SUM);
5660
5661   /* Note that we explicitly do not want any alias information for this
5662      memory, so that we kill all other live memories.  Otherwise we don't
5663      satisfy the full barrier semantics of the intrinsic.  */
5664   mem = validize_mem (gen_rtx_MEM (mode, addr));
5665
5666   set_mem_align (mem, get_pointer_alignment (loc, BIGGEST_ALIGNMENT));
5667   set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5668   MEM_VOLATILE_P (mem) = 1;
5669
5670   return mem;
5671 }
5672
5673 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5674    EXP is the CALL_EXPR.  CODE is the rtx code
5675    that corresponds to the arithmetic or logical operation from the name;
5676    an exception here is that NOT actually means NAND.  TARGET is an optional
5677    place for us to store the results; AFTER is true if this is the
5678    fetch_and_xxx form.  IGNORE is true if we don't actually care about
5679    the result of the operation at all.  */
5680
5681 static rtx
5682 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5683                                enum rtx_code code, bool after,
5684                                rtx target, bool ignore)
5685 {
5686   rtx val, mem;
5687   enum machine_mode old_mode;
5688   location_t loc = EXPR_LOCATION (exp);
5689
5690   if (code == NOT && warn_sync_nand)
5691     {
5692       tree fndecl = get_callee_fndecl (exp);
5693       enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5694
5695       static bool warned_f_a_n, warned_n_a_f;
5696
5697       switch (fcode)
5698         {
5699         case BUILT_IN_FETCH_AND_NAND_1:
5700         case BUILT_IN_FETCH_AND_NAND_2:
5701         case BUILT_IN_FETCH_AND_NAND_4:
5702         case BUILT_IN_FETCH_AND_NAND_8:
5703         case BUILT_IN_FETCH_AND_NAND_16:
5704
5705           if (warned_f_a_n)
5706             break;
5707
5708           fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
5709           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5710           warned_f_a_n = true;
5711           break;
5712
5713         case BUILT_IN_NAND_AND_FETCH_1:
5714         case BUILT_IN_NAND_AND_FETCH_2:
5715         case BUILT_IN_NAND_AND_FETCH_4:
5716         case BUILT_IN_NAND_AND_FETCH_8:
5717         case BUILT_IN_NAND_AND_FETCH_16:
5718
5719           if (warned_n_a_f)
5720             break;
5721
5722           fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
5723           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5724           warned_n_a_f = true;
5725           break;
5726
5727         default:
5728           gcc_unreachable ();
5729         }
5730     }
5731
5732   /* Expand the operands.  */
5733   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5734
5735   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5736   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5737      of CONST_INTs, where we know the old_mode only from the call argument.  */
5738   old_mode = GET_MODE (val);
5739   if (old_mode == VOIDmode)
5740     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5741   val = convert_modes (mode, old_mode, val, 1);
5742
5743   if (ignore)
5744     return expand_sync_operation (mem, val, code);
5745   else
5746     return expand_sync_fetch_operation (mem, val, code, after, target);
5747 }
5748
5749 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5750    intrinsics. EXP is the CALL_EXPR.  IS_BOOL is
5751    true if this is the boolean form.  TARGET is a place for us to store the
5752    results; this is NOT optional if IS_BOOL is true.  */
5753
5754 static rtx
5755 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5756                                  bool is_bool, rtx target)
5757 {
5758   rtx old_val, new_val, mem;
5759   enum machine_mode old_mode;
5760
5761   /* Expand the operands.  */
5762   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5763
5764
5765   old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX,
5766                          mode, EXPAND_NORMAL);
5767   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5768      of CONST_INTs, where we know the old_mode only from the call argument.  */
5769   old_mode = GET_MODE (old_val);
5770   if (old_mode == VOIDmode)
5771     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5772   old_val = convert_modes (mode, old_mode, old_val, 1);
5773
5774   new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL_RTX,
5775                          mode, EXPAND_NORMAL);
5776   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5777      of CONST_INTs, where we know the old_mode only from the call argument.  */
5778   old_mode = GET_MODE (new_val);
5779   if (old_mode == VOIDmode)
5780     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2)));
5781   new_val = convert_modes (mode, old_mode, new_val, 1);
5782
5783   if (is_bool)
5784     return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5785   else
5786     return expand_val_compare_and_swap (mem, old_val, new_val, target);
5787 }
5788
5789 /* Expand the __sync_lock_test_and_set intrinsic.  Note that the most
5790    general form is actually an atomic exchange, and some targets only
5791    support a reduced form with the second argument being a constant 1.
5792    EXP is the CALL_EXPR; TARGET is an optional place for us to store
5793    the results.  */
5794
5795 static rtx
5796 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
5797                                   rtx target)
5798 {
5799   rtx val, mem;
5800   enum machine_mode old_mode;
5801
5802   /* Expand the operands.  */
5803   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5804   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5805   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5806      of CONST_INTs, where we know the old_mode only from the call argument.  */
5807   old_mode = GET_MODE (val);
5808   if (old_mode == VOIDmode)
5809     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5810   val = convert_modes (mode, old_mode, val, 1);
5811
5812   return expand_sync_lock_test_and_set (mem, val, target);
5813 }
5814
5815 /* Expand the __sync_synchronize intrinsic.  */
5816
5817 static void
5818 expand_builtin_synchronize (void)
5819 {
5820   gimple x;
5821   VEC (tree, gc) *v_clobbers;
5822
5823 #ifdef HAVE_memory_barrier
5824   if (HAVE_memory_barrier)
5825     {
5826       emit_insn (gen_memory_barrier ());
5827       return;
5828     }
5829 #endif
5830
5831   if (synchronize_libfunc != NULL_RTX)
5832     {
5833       emit_library_call (synchronize_libfunc, LCT_NORMAL, VOIDmode, 0);
5834       return;
5835     }
5836
5837   /* If no explicit memory barrier instruction is available, create an
5838      empty asm stmt with a memory clobber.  */
5839   v_clobbers = VEC_alloc (tree, gc, 1);
5840   VEC_quick_push (tree, v_clobbers,
5841                   tree_cons (NULL, build_string (6, "memory"), NULL));
5842   x = gimple_build_asm_vec ("", NULL, NULL, v_clobbers, NULL);
5843   gimple_asm_set_volatile (x, true);
5844   expand_asm_stmt (x);
5845 }
5846
5847 /* Expand the __sync_lock_release intrinsic.  EXP is the CALL_EXPR.  */
5848
5849 static void
5850 expand_builtin_lock_release (enum machine_mode mode, tree exp)
5851 {
5852   enum insn_code icode;
5853   rtx mem, insn;
5854   rtx val = const0_rtx;
5855
5856   /* Expand the operands.  */
5857   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5858
5859   /* If there is an explicit operation in the md file, use it.  */
5860   icode = sync_lock_release[mode];
5861   if (icode != CODE_FOR_nothing)
5862     {
5863       if (!insn_data[icode].operand[1].predicate (val, mode))
5864         val = force_reg (mode, val);
5865
5866       insn = GEN_FCN (icode) (mem, val);
5867       if (insn)
5868         {
5869           emit_insn (insn);
5870           return;
5871         }
5872     }
5873
5874   /* Otherwise we can implement this operation by emitting a barrier
5875      followed by a store of zero.  */
5876   expand_builtin_synchronize ();
5877   emit_move_insn (mem, val);
5878 }
5879 \f
5880 /* Expand an expression EXP that calls a built-in function,
5881    with result going to TARGET if that's convenient
5882    (and in mode MODE if that's convenient).
5883    SUBTARGET may be used as the target for computing one of EXP's operands.
5884    IGNORE is nonzero if the value is to be ignored.  */
5885
5886 rtx
5887 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5888                 int ignore)
5889 {
5890   tree fndecl = get_callee_fndecl (exp);
5891   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5892   enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5893
5894   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5895     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5896
5897   /* When not optimizing, generate calls to library functions for a certain
5898      set of builtins.  */
5899   if (!optimize
5900       && !called_as_built_in (fndecl)
5901       && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5902       && fcode != BUILT_IN_ALLOCA
5903       && fcode != BUILT_IN_FREE)
5904     return expand_call (exp, target, ignore);
5905
5906   /* The built-in function expanders test for target == const0_rtx
5907      to determine whether the function's result will be ignored.  */
5908   if (ignore)
5909     target = const0_rtx;
5910
5911   /* If the result of a pure or const built-in function is ignored, and
5912      none of its arguments are volatile, we can avoid expanding the
5913      built-in call and just evaluate the arguments for side-effects.  */
5914   if (target == const0_rtx
5915       && (DECL_PURE_P (fndecl) || TREE_READONLY (fndecl)))
5916     {
5917       bool volatilep = false;
5918       tree arg;
5919       call_expr_arg_iterator iter;
5920
5921       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5922         if (TREE_THIS_VOLATILE (arg))
5923           {
5924             volatilep = true;
5925             break;
5926           }
5927
5928       if (! volatilep)
5929         {
5930           FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5931             expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5932           return const0_rtx;
5933         }
5934     }
5935
5936   switch (fcode)
5937     {
5938     CASE_FLT_FN (BUILT_IN_FABS):
5939       target = expand_builtin_fabs (exp, target, subtarget);
5940       if (target)
5941         return target;
5942       break;
5943
5944     CASE_FLT_FN (BUILT_IN_COPYSIGN):
5945       target = expand_builtin_copysign (exp, target, subtarget);
5946       if (target)
5947         return target;
5948       break;
5949
5950       /* Just do a normal library call if we were unable to fold
5951          the values.  */
5952     CASE_FLT_FN (BUILT_IN_CABS):
5953       break;
5954
5955     CASE_FLT_FN (BUILT_IN_EXP):
5956     CASE_FLT_FN (BUILT_IN_EXP10):
5957     CASE_FLT_FN (BUILT_IN_POW10):
5958     CASE_FLT_FN (BUILT_IN_EXP2):
5959     CASE_FLT_FN (BUILT_IN_EXPM1):
5960     CASE_FLT_FN (BUILT_IN_LOGB):
5961     CASE_FLT_FN (BUILT_IN_LOG):
5962     CASE_FLT_FN (BUILT_IN_LOG10):
5963     CASE_FLT_FN (BUILT_IN_LOG2):
5964     CASE_FLT_FN (BUILT_IN_LOG1P):
5965     CASE_FLT_FN (BUILT_IN_TAN):
5966     CASE_FLT_FN (BUILT_IN_ASIN):
5967     CASE_FLT_FN (BUILT_IN_ACOS):
5968     CASE_FLT_FN (BUILT_IN_ATAN):
5969     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5970       /* Treat these like sqrt only if unsafe math optimizations are allowed,
5971          because of possible accuracy problems.  */
5972       if (! flag_unsafe_math_optimizations)
5973         break;
5974     CASE_FLT_FN (BUILT_IN_SQRT):
5975     CASE_FLT_FN (BUILT_IN_FLOOR):
5976     CASE_FLT_FN (BUILT_IN_CEIL):
5977     CASE_FLT_FN (BUILT_IN_TRUNC):
5978     CASE_FLT_FN (BUILT_IN_ROUND):
5979     CASE_FLT_FN (BUILT_IN_NEARBYINT):
5980     CASE_FLT_FN (BUILT_IN_RINT):
5981       target = expand_builtin_mathfn (exp, target, subtarget);
5982       if (target)
5983         return target;
5984       break;
5985
5986     CASE_FLT_FN (BUILT_IN_ILOGB):
5987       if (! flag_unsafe_math_optimizations)
5988         break;
5989     CASE_FLT_FN (BUILT_IN_ISINF):
5990     CASE_FLT_FN (BUILT_IN_FINITE):
5991     case BUILT_IN_ISFINITE:
5992     case BUILT_IN_ISNORMAL:
5993       target = expand_builtin_interclass_mathfn (exp, target, subtarget);
5994       if (target)
5995         return target;
5996       break;
5997
5998     CASE_FLT_FN (BUILT_IN_LCEIL):
5999     CASE_FLT_FN (BUILT_IN_LLCEIL):
6000     CASE_FLT_FN (BUILT_IN_LFLOOR):
6001     CASE_FLT_FN (BUILT_IN_LLFLOOR):
6002       target = expand_builtin_int_roundingfn (exp, target);
6003       if (target)
6004         return target;
6005       break;
6006
6007     CASE_FLT_FN (BUILT_IN_LRINT):
6008     CASE_FLT_FN (BUILT_IN_LLRINT):
6009     CASE_FLT_FN (BUILT_IN_LROUND):
6010     CASE_FLT_FN (BUILT_IN_LLROUND):
6011       target = expand_builtin_int_roundingfn_2 (exp, target);
6012       if (target)
6013         return target;
6014       break;
6015
6016     CASE_FLT_FN (BUILT_IN_POW):
6017       target = expand_builtin_pow (exp, target, subtarget);
6018       if (target)
6019         return target;
6020       break;
6021
6022     CASE_FLT_FN (BUILT_IN_POWI):
6023       target = expand_builtin_powi (exp, target, subtarget);
6024       if (target)
6025         return target;
6026       break;
6027
6028     CASE_FLT_FN (BUILT_IN_ATAN2):
6029     CASE_FLT_FN (BUILT_IN_LDEXP):
6030     CASE_FLT_FN (BUILT_IN_SCALB):
6031     CASE_FLT_FN (BUILT_IN_SCALBN):
6032     CASE_FLT_FN (BUILT_IN_SCALBLN):
6033       if (! flag_unsafe_math_optimizations)
6034         break;
6035
6036     CASE_FLT_FN (BUILT_IN_FMOD):
6037     CASE_FLT_FN (BUILT_IN_REMAINDER):
6038     CASE_FLT_FN (BUILT_IN_DREM):
6039       target = expand_builtin_mathfn_2 (exp, target, subtarget);
6040       if (target)
6041         return target;
6042       break;
6043
6044     CASE_FLT_FN (BUILT_IN_CEXPI):
6045       target = expand_builtin_cexpi (exp, target, subtarget);
6046       gcc_assert (target);
6047       return target;
6048
6049     CASE_FLT_FN (BUILT_IN_SIN):
6050     CASE_FLT_FN (BUILT_IN_COS):
6051       if (! flag_unsafe_math_optimizations)
6052         break;
6053       target = expand_builtin_mathfn_3 (exp, target, subtarget);
6054       if (target)
6055         return target;
6056       break;
6057
6058     CASE_FLT_FN (BUILT_IN_SINCOS):
6059       if (! flag_unsafe_math_optimizations)
6060         break;
6061       target = expand_builtin_sincos (exp);
6062       if (target)
6063         return target;
6064       break;
6065
6066     case BUILT_IN_APPLY_ARGS:
6067       return expand_builtin_apply_args ();
6068
6069       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
6070          FUNCTION with a copy of the parameters described by
6071          ARGUMENTS, and ARGSIZE.  It returns a block of memory
6072          allocated on the stack into which is stored all the registers
6073          that might possibly be used for returning the result of a
6074          function.  ARGUMENTS is the value returned by
6075          __builtin_apply_args.  ARGSIZE is the number of bytes of
6076          arguments that must be copied.  ??? How should this value be
6077          computed?  We'll also need a safe worst case value for varargs
6078          functions.  */
6079     case BUILT_IN_APPLY:
6080       if (!validate_arglist (exp, POINTER_TYPE,
6081                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
6082           && !validate_arglist (exp, REFERENCE_TYPE,
6083                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6084         return const0_rtx;
6085       else
6086         {
6087           rtx ops[3];
6088
6089           ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
6090           ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
6091           ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
6092
6093           return expand_builtin_apply (ops[0], ops[1], ops[2]);
6094         }
6095
6096       /* __builtin_return (RESULT) causes the function to return the
6097          value described by RESULT.  RESULT is address of the block of
6098          memory returned by __builtin_apply.  */
6099     case BUILT_IN_RETURN:
6100       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6101         expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
6102       return const0_rtx;
6103
6104     case BUILT_IN_SAVEREGS:
6105       return expand_builtin_saveregs ();
6106
6107     case BUILT_IN_ARGS_INFO:
6108       return expand_builtin_args_info (exp);
6109
6110     case BUILT_IN_VA_ARG_PACK:
6111       /* All valid uses of __builtin_va_arg_pack () are removed during
6112          inlining.  */
6113       error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
6114       return const0_rtx;
6115
6116     case BUILT_IN_VA_ARG_PACK_LEN:
6117       /* All valid uses of __builtin_va_arg_pack_len () are removed during
6118          inlining.  */
6119       error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
6120       return const0_rtx;
6121
6122       /* Return the address of the first anonymous stack arg.  */
6123     case BUILT_IN_NEXT_ARG:
6124       if (fold_builtin_next_arg (exp, false))
6125         return const0_rtx;
6126       return expand_builtin_next_arg ();
6127
6128     case BUILT_IN_CLEAR_CACHE:
6129       target = expand_builtin___clear_cache (exp);
6130       if (target)
6131         return target;
6132       break;
6133
6134     case BUILT_IN_CLASSIFY_TYPE:
6135       return expand_builtin_classify_type (exp);
6136
6137     case BUILT_IN_CONSTANT_P:
6138       return const0_rtx;
6139
6140     case BUILT_IN_FRAME_ADDRESS:
6141     case BUILT_IN_RETURN_ADDRESS:
6142       return expand_builtin_frame_address (fndecl, exp);
6143
6144     /* Returns the address of the area where the structure is returned.
6145        0 otherwise.  */
6146     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
6147       if (call_expr_nargs (exp) != 0
6148           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
6149           || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
6150         return const0_rtx;
6151       else
6152         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6153
6154     case BUILT_IN_ALLOCA:
6155       target = expand_builtin_alloca (exp, target);
6156       if (target)
6157         return target;
6158       break;
6159
6160     case BUILT_IN_STACK_SAVE:
6161       return expand_stack_save ();
6162
6163     case BUILT_IN_STACK_RESTORE:
6164       expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6165       return const0_rtx;
6166
6167     case BUILT_IN_BSWAP32:
6168     case BUILT_IN_BSWAP64:
6169       target = expand_builtin_bswap (exp, target, subtarget);
6170
6171       if (target)
6172         return target;
6173       break;
6174
6175     CASE_INT_FN (BUILT_IN_FFS):
6176     case BUILT_IN_FFSIMAX:
6177       target = expand_builtin_unop (target_mode, exp, target,
6178                                     subtarget, ffs_optab);
6179       if (target)
6180         return target;
6181       break;
6182
6183     CASE_INT_FN (BUILT_IN_CLZ):
6184     case BUILT_IN_CLZIMAX:
6185       target = expand_builtin_unop (target_mode, exp, target,
6186                                     subtarget, clz_optab);
6187       if (target)
6188         return target;
6189       break;
6190
6191     CASE_INT_FN (BUILT_IN_CTZ):
6192     case BUILT_IN_CTZIMAX:
6193       target = expand_builtin_unop (target_mode, exp, target,
6194                                     subtarget, ctz_optab);
6195       if (target)
6196         return target;
6197       break;
6198
6199     CASE_INT_FN (BUILT_IN_POPCOUNT):
6200     case BUILT_IN_POPCOUNTIMAX:
6201       target = expand_builtin_unop (target_mode, exp, target,
6202                                     subtarget, popcount_optab);
6203       if (target)
6204         return target;
6205       break;
6206
6207     CASE_INT_FN (BUILT_IN_PARITY):
6208     case BUILT_IN_PARITYIMAX:
6209       target = expand_builtin_unop (target_mode, exp, target,
6210                                     subtarget, parity_optab);
6211       if (target)
6212         return target;
6213       break;
6214
6215     case BUILT_IN_STRLEN:
6216       target = expand_builtin_strlen (exp, target, target_mode);
6217       if (target)
6218         return target;
6219       break;
6220
6221     case BUILT_IN_STRCPY:
6222       target = expand_builtin_strcpy (exp, target);
6223       if (target)
6224         return target;
6225       break;
6226
6227     case BUILT_IN_STRNCPY:
6228       target = expand_builtin_strncpy (exp, target);
6229       if (target)
6230         return target;
6231       break;
6232
6233     case BUILT_IN_STPCPY:
6234       target = expand_builtin_stpcpy (exp, target, mode);
6235       if (target)
6236         return target;
6237       break;
6238
6239     case BUILT_IN_MEMCPY:
6240       target = expand_builtin_memcpy (exp, target);
6241       if (target)
6242         return target;
6243       break;
6244
6245     case BUILT_IN_MEMPCPY:
6246       target = expand_builtin_mempcpy (exp, target, mode);
6247       if (target)
6248         return target;
6249       break;
6250
6251     case BUILT_IN_MEMSET:
6252       target = expand_builtin_memset (exp, target, mode);
6253       if (target)
6254         return target;
6255       break;
6256
6257     case BUILT_IN_BZERO:
6258       target = expand_builtin_bzero (exp);
6259       if (target)
6260         return target;
6261       break;
6262
6263     case BUILT_IN_STRCMP:
6264       target = expand_builtin_strcmp (exp, target);
6265       if (target)
6266         return target;
6267       break;
6268
6269     case BUILT_IN_STRNCMP:
6270       target = expand_builtin_strncmp (exp, target, mode);
6271       if (target)
6272         return target;
6273       break;
6274
6275     case BUILT_IN_BCMP:
6276     case BUILT_IN_MEMCMP:
6277       target = expand_builtin_memcmp (exp, target, mode);
6278       if (target)
6279         return target;
6280       break;
6281
6282     case BUILT_IN_SETJMP:
6283       /* This should have been lowered to the builtins below.  */
6284       gcc_unreachable ();
6285
6286     case BUILT_IN_SETJMP_SETUP:
6287       /* __builtin_setjmp_setup is passed a pointer to an array of five words
6288           and the receiver label.  */
6289       if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6290         {
6291           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6292                                       VOIDmode, EXPAND_NORMAL);
6293           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6294           rtx label_r = label_rtx (label);
6295
6296           /* This is copied from the handling of non-local gotos.  */
6297           expand_builtin_setjmp_setup (buf_addr, label_r);
6298           nonlocal_goto_handler_labels
6299             = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6300                                  nonlocal_goto_handler_labels);
6301           /* ??? Do not let expand_label treat us as such since we would
6302              not want to be both on the list of non-local labels and on
6303              the list of forced labels.  */
6304           FORCED_LABEL (label) = 0;
6305           return const0_rtx;
6306         }
6307       break;
6308
6309     case BUILT_IN_SETJMP_DISPATCHER:
6310        /* __builtin_setjmp_dispatcher is passed the dispatcher label.  */
6311       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6312         {
6313           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6314           rtx label_r = label_rtx (label);
6315
6316           /* Remove the dispatcher label from the list of non-local labels
6317              since the receiver labels have been added to it above.  */
6318           remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6319           return const0_rtx;
6320         }
6321       break;
6322
6323     case BUILT_IN_SETJMP_RECEIVER:
6324        /* __builtin_setjmp_receiver is passed the receiver label.  */
6325       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6326         {
6327           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6328           rtx label_r = label_rtx (label);
6329
6330           expand_builtin_setjmp_receiver (label_r);
6331           return const0_rtx;
6332         }
6333       break;
6334
6335       /* __builtin_longjmp is passed a pointer to an array of five words.
6336          It's similar to the C library longjmp function but works with
6337          __builtin_setjmp above.  */
6338     case BUILT_IN_LONGJMP:
6339       if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6340         {
6341           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6342                                       VOIDmode, EXPAND_NORMAL);
6343           rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6344
6345           if (value != const1_rtx)
6346             {
6347               error ("%<__builtin_longjmp%> second argument must be 1");
6348               return const0_rtx;
6349             }
6350
6351           expand_builtin_longjmp (buf_addr, value);
6352           return const0_rtx;
6353         }
6354       break;
6355
6356     case BUILT_IN_NONLOCAL_GOTO:
6357       target = expand_builtin_nonlocal_goto (exp);
6358       if (target)
6359         return target;
6360       break;
6361
6362       /* This updates the setjmp buffer that is its argument with the value
6363          of the current stack pointer.  */
6364     case BUILT_IN_UPDATE_SETJMP_BUF:
6365       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6366         {
6367           rtx buf_addr
6368             = expand_normal (CALL_EXPR_ARG (exp, 0));
6369
6370           expand_builtin_update_setjmp_buf (buf_addr);
6371           return const0_rtx;
6372         }
6373       break;
6374
6375     case BUILT_IN_TRAP:
6376       expand_builtin_trap ();
6377       return const0_rtx;
6378
6379     case BUILT_IN_UNREACHABLE:
6380       expand_builtin_unreachable ();
6381       return const0_rtx;
6382
6383     case BUILT_IN_PRINTF:
6384       target = expand_builtin_printf (exp, target, mode, false);
6385       if (target)
6386         return target;
6387       break;
6388
6389     case BUILT_IN_PRINTF_UNLOCKED:
6390       target = expand_builtin_printf (exp, target, mode, true);
6391       if (target)
6392         return target;
6393       break;
6394
6395     case BUILT_IN_FPRINTF:
6396       target = expand_builtin_fprintf (exp, target, mode, false);
6397       if (target)
6398         return target;
6399       break;
6400
6401     case BUILT_IN_FPRINTF_UNLOCKED:
6402       target = expand_builtin_fprintf (exp, target, mode, true);
6403       if (target)
6404         return target;
6405       break;
6406
6407     case BUILT_IN_SPRINTF:
6408       target = expand_builtin_sprintf (exp, target, mode);
6409       if (target)
6410         return target;
6411       break;
6412
6413     CASE_FLT_FN (BUILT_IN_SIGNBIT):
6414     case BUILT_IN_SIGNBITD32:
6415     case BUILT_IN_SIGNBITD64:
6416     case BUILT_IN_SIGNBITD128:
6417       target = expand_builtin_signbit (exp, target);
6418       if (target)
6419         return target;
6420       break;
6421
6422       /* Various hooks for the DWARF 2 __throw routine.  */
6423     case BUILT_IN_UNWIND_INIT:
6424       expand_builtin_unwind_init ();
6425       return const0_rtx;
6426     case BUILT_IN_DWARF_CFA:
6427       return virtual_cfa_rtx;
6428 #ifdef DWARF2_UNWIND_INFO
6429     case BUILT_IN_DWARF_SP_COLUMN:
6430       return expand_builtin_dwarf_sp_column ();
6431     case BUILT_IN_INIT_DWARF_REG_SIZES:
6432       expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6433       return const0_rtx;
6434 #endif
6435     case BUILT_IN_FROB_RETURN_ADDR:
6436       return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6437     case BUILT_IN_EXTRACT_RETURN_ADDR:
6438       return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6439     case BUILT_IN_EH_RETURN:
6440       expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6441                                 CALL_EXPR_ARG (exp, 1));
6442       return const0_rtx;
6443 #ifdef EH_RETURN_DATA_REGNO
6444     case BUILT_IN_EH_RETURN_DATA_REGNO:
6445       return expand_builtin_eh_return_data_regno (exp);
6446 #endif
6447     case BUILT_IN_EXTEND_POINTER:
6448       return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6449     case BUILT_IN_EH_POINTER:
6450       return expand_builtin_eh_pointer (exp);
6451     case BUILT_IN_EH_FILTER:
6452       return expand_builtin_eh_filter (exp);
6453     case BUILT_IN_EH_COPY_VALUES:
6454       return expand_builtin_eh_copy_values (exp);
6455
6456     case BUILT_IN_VA_START:
6457       return expand_builtin_va_start (exp);
6458     case BUILT_IN_VA_END:
6459       return expand_builtin_va_end (exp);
6460     case BUILT_IN_VA_COPY:
6461       return expand_builtin_va_copy (exp);
6462     case BUILT_IN_EXPECT:
6463       return expand_builtin_expect (exp, target);
6464     case BUILT_IN_PREFETCH:
6465       expand_builtin_prefetch (exp);
6466       return const0_rtx;
6467
6468     case BUILT_IN_PROFILE_FUNC_ENTER:
6469       return expand_builtin_profile_func (false);
6470     case BUILT_IN_PROFILE_FUNC_EXIT:
6471       return expand_builtin_profile_func (true);
6472
6473     case BUILT_IN_INIT_TRAMPOLINE:
6474       return expand_builtin_init_trampoline (exp);
6475     case BUILT_IN_ADJUST_TRAMPOLINE:
6476       return expand_builtin_adjust_trampoline (exp);
6477
6478     case BUILT_IN_FORK:
6479     case BUILT_IN_EXECL:
6480     case BUILT_IN_EXECV:
6481     case BUILT_IN_EXECLP:
6482     case BUILT_IN_EXECLE:
6483     case BUILT_IN_EXECVP:
6484     case BUILT_IN_EXECVE:
6485       target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6486       if (target)
6487         return target;
6488       break;
6489
6490     case BUILT_IN_FETCH_AND_ADD_1:
6491     case BUILT_IN_FETCH_AND_ADD_2:
6492     case BUILT_IN_FETCH_AND_ADD_4:
6493     case BUILT_IN_FETCH_AND_ADD_8:
6494     case BUILT_IN_FETCH_AND_ADD_16:
6495       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6496       target = expand_builtin_sync_operation (mode, exp, PLUS,
6497                                               false, target, ignore);
6498       if (target)
6499         return target;
6500       break;
6501
6502     case BUILT_IN_FETCH_AND_SUB_1:
6503     case BUILT_IN_FETCH_AND_SUB_2:
6504     case BUILT_IN_FETCH_AND_SUB_4:
6505     case BUILT_IN_FETCH_AND_SUB_8:
6506     case BUILT_IN_FETCH_AND_SUB_16:
6507       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6508       target = expand_builtin_sync_operation (mode, exp, MINUS,
6509                                               false, target, ignore);
6510       if (target)
6511         return target;
6512       break;
6513
6514     case BUILT_IN_FETCH_AND_OR_1:
6515     case BUILT_IN_FETCH_AND_OR_2:
6516     case BUILT_IN_FETCH_AND_OR_4:
6517     case BUILT_IN_FETCH_AND_OR_8:
6518     case BUILT_IN_FETCH_AND_OR_16:
6519       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6520       target = expand_builtin_sync_operation (mode, exp, IOR,
6521                                               false, target, ignore);
6522       if (target)
6523         return target;
6524       break;
6525
6526     case BUILT_IN_FETCH_AND_AND_1:
6527     case BUILT_IN_FETCH_AND_AND_2:
6528     case BUILT_IN_FETCH_AND_AND_4:
6529     case BUILT_IN_FETCH_AND_AND_8:
6530     case BUILT_IN_FETCH_AND_AND_16:
6531       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6532       target = expand_builtin_sync_operation (mode, exp, AND,
6533                                               false, target, ignore);
6534       if (target)
6535         return target;
6536       break;
6537
6538     case BUILT_IN_FETCH_AND_XOR_1:
6539     case BUILT_IN_FETCH_AND_XOR_2:
6540     case BUILT_IN_FETCH_AND_XOR_4:
6541     case BUILT_IN_FETCH_AND_XOR_8:
6542     case BUILT_IN_FETCH_AND_XOR_16:
6543       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6544       target = expand_builtin_sync_operation (mode, exp, XOR,
6545                                               false, target, ignore);
6546       if (target)
6547         return target;
6548       break;
6549
6550     case BUILT_IN_FETCH_AND_NAND_1:
6551     case BUILT_IN_FETCH_AND_NAND_2:
6552     case BUILT_IN_FETCH_AND_NAND_4:
6553     case BUILT_IN_FETCH_AND_NAND_8:
6554     case BUILT_IN_FETCH_AND_NAND_16:
6555       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6556       target = expand_builtin_sync_operation (mode, exp, NOT,
6557                                               false, target, ignore);
6558       if (target)
6559         return target;
6560       break;
6561
6562     case BUILT_IN_ADD_AND_FETCH_1:
6563     case BUILT_IN_ADD_AND_FETCH_2:
6564     case BUILT_IN_ADD_AND_FETCH_4:
6565     case BUILT_IN_ADD_AND_FETCH_8:
6566     case BUILT_IN_ADD_AND_FETCH_16:
6567       mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6568       target = expand_builtin_sync_operation (mode, exp, PLUS,
6569                                               true, target, ignore);
6570       if (target)
6571         return target;
6572       break;
6573
6574     case BUILT_IN_SUB_AND_FETCH_1:
6575     case BUILT_IN_SUB_AND_FETCH_2:
6576     case BUILT_IN_SUB_AND_FETCH_4:
6577     case BUILT_IN_SUB_AND_FETCH_8:
6578     case BUILT_IN_SUB_AND_FETCH_16:
6579       mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6580       target = expand_builtin_sync_operation (mode, exp, MINUS,
6581                                               true, target, ignore);
6582       if (target)
6583         return target;
6584       break;
6585
6586     case BUILT_IN_OR_AND_FETCH_1:
6587     case BUILT_IN_OR_AND_FETCH_2:
6588     case BUILT_IN_OR_AND_FETCH_4:
6589     case BUILT_IN_OR_AND_FETCH_8:
6590     case BUILT_IN_OR_AND_FETCH_16:
6591       mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6592       target = expand_builtin_sync_operation (mode, exp, IOR,
6593                                               true, target, ignore);
6594       if (target)
6595         return target;
6596       break;
6597
6598     case BUILT_IN_AND_AND_FETCH_1:
6599     case BUILT_IN_AND_AND_FETCH_2:
6600     case BUILT_IN_AND_AND_FETCH_4:
6601     case BUILT_IN_AND_AND_FETCH_8:
6602     case BUILT_IN_AND_AND_FETCH_16:
6603       mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6604       target = expand_builtin_sync_operation (mode, exp, AND,
6605                                               true, target, ignore);
6606       if (target)
6607         return target;
6608       break;
6609
6610     case BUILT_IN_XOR_AND_FETCH_1:
6611     case BUILT_IN_XOR_AND_FETCH_2:
6612     case BUILT_IN_XOR_AND_FETCH_4:
6613     case BUILT_IN_XOR_AND_FETCH_8:
6614     case BUILT_IN_XOR_AND_FETCH_16:
6615       mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6616       target = expand_builtin_sync_operation (mode, exp, XOR,
6617                                               true, target, ignore);
6618       if (target)
6619         return target;
6620       break;
6621
6622     case BUILT_IN_NAND_AND_FETCH_1:
6623     case BUILT_IN_NAND_AND_FETCH_2:
6624     case BUILT_IN_NAND_AND_FETCH_4:
6625     case BUILT_IN_NAND_AND_FETCH_8:
6626     case BUILT_IN_NAND_AND_FETCH_16:
6627       mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6628       target = expand_builtin_sync_operation (mode, exp, NOT,
6629                                               true, target, ignore);
6630       if (target)
6631         return target;
6632       break;
6633
6634     case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6635     case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6636     case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6637     case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6638     case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6639       if (mode == VOIDmode)
6640         mode = TYPE_MODE (boolean_type_node);
6641       if (!target || !register_operand (target, mode))
6642         target = gen_reg_rtx (mode);
6643
6644       mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6645       target = expand_builtin_compare_and_swap (mode, exp, true, target);
6646       if (target)
6647         return target;
6648       break;
6649
6650     case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6651     case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6652     case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6653     case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6654     case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6655       mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6656       target = expand_builtin_compare_and_swap (mode, exp, false, target);
6657       if (target)
6658         return target;
6659       break;
6660
6661     case BUILT_IN_LOCK_TEST_AND_SET_1:
6662     case BUILT_IN_LOCK_TEST_AND_SET_2:
6663     case BUILT_IN_LOCK_TEST_AND_SET_4:
6664     case BUILT_IN_LOCK_TEST_AND_SET_8:
6665     case BUILT_IN_LOCK_TEST_AND_SET_16:
6666       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6667       target = expand_builtin_lock_test_and_set (mode, exp, target);
6668       if (target)
6669         return target;
6670       break;
6671
6672     case BUILT_IN_LOCK_RELEASE_1:
6673     case BUILT_IN_LOCK_RELEASE_2:
6674     case BUILT_IN_LOCK_RELEASE_4:
6675     case BUILT_IN_LOCK_RELEASE_8:
6676     case BUILT_IN_LOCK_RELEASE_16:
6677       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6678       expand_builtin_lock_release (mode, exp);
6679       return const0_rtx;
6680
6681     case BUILT_IN_SYNCHRONIZE:
6682       expand_builtin_synchronize ();
6683       return const0_rtx;
6684
6685     case BUILT_IN_OBJECT_SIZE:
6686       return expand_builtin_object_size (exp);
6687
6688     case BUILT_IN_MEMCPY_CHK:
6689     case BUILT_IN_MEMPCPY_CHK:
6690     case BUILT_IN_MEMMOVE_CHK:
6691     case BUILT_IN_MEMSET_CHK:
6692       target = expand_builtin_memory_chk (exp, target, mode, fcode);
6693       if (target)
6694         return target;
6695       break;
6696
6697     case BUILT_IN_STRCPY_CHK:
6698     case BUILT_IN_STPCPY_CHK:
6699     case BUILT_IN_STRNCPY_CHK:
6700     case BUILT_IN_STRCAT_CHK:
6701     case BUILT_IN_STRNCAT_CHK:
6702     case BUILT_IN_SNPRINTF_CHK:
6703     case BUILT_IN_VSNPRINTF_CHK:
6704       maybe_emit_chk_warning (exp, fcode);
6705       break;
6706
6707     case BUILT_IN_SPRINTF_CHK:
6708     case BUILT_IN_VSPRINTF_CHK:
6709       maybe_emit_sprintf_chk_warning (exp, fcode);
6710       break;
6711
6712     case BUILT_IN_FREE:
6713       maybe_emit_free_warning (exp);
6714       break;
6715
6716     default:    /* just do library call, if unknown builtin */
6717       break;
6718     }
6719
6720   /* The switch statement above can drop through to cause the function
6721      to be called normally.  */
6722   return expand_call (exp, target, ignore);
6723 }
6724
6725 /* Determine whether a tree node represents a call to a built-in
6726    function.  If the tree T is a call to a built-in function with
6727    the right number of arguments of the appropriate types, return
6728    the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6729    Otherwise the return value is END_BUILTINS.  */
6730
6731 enum built_in_function
6732 builtin_mathfn_code (const_tree t)
6733 {
6734   const_tree fndecl, arg, parmlist;
6735   const_tree argtype, parmtype;
6736   const_call_expr_arg_iterator iter;
6737
6738   if (TREE_CODE (t) != CALL_EXPR
6739       || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6740     return END_BUILTINS;
6741
6742   fndecl = get_callee_fndecl (t);
6743   if (fndecl == NULL_TREE
6744       || TREE_CODE (fndecl) != FUNCTION_DECL
6745       || ! DECL_BUILT_IN (fndecl)
6746       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6747     return END_BUILTINS;
6748
6749   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6750   init_const_call_expr_arg_iterator (t, &iter);
6751   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6752     {
6753       /* If a function doesn't take a variable number of arguments,
6754          the last element in the list will have type `void'.  */
6755       parmtype = TREE_VALUE (parmlist);
6756       if (VOID_TYPE_P (parmtype))
6757         {
6758           if (more_const_call_expr_args_p (&iter))
6759             return END_BUILTINS;
6760           return DECL_FUNCTION_CODE (fndecl);
6761         }
6762
6763       if (! more_const_call_expr_args_p (&iter))
6764         return END_BUILTINS;
6765
6766       arg = next_const_call_expr_arg (&iter);
6767       argtype = TREE_TYPE (arg);
6768
6769       if (SCALAR_FLOAT_TYPE_P (parmtype))
6770         {
6771           if (! SCALAR_FLOAT_TYPE_P (argtype))
6772             return END_BUILTINS;
6773         }
6774       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6775         {
6776           if (! COMPLEX_FLOAT_TYPE_P (argtype))
6777             return END_BUILTINS;
6778         }
6779       else if (POINTER_TYPE_P (parmtype))
6780         {
6781           if (! POINTER_TYPE_P (argtype))
6782             return END_BUILTINS;
6783         }
6784       else if (INTEGRAL_TYPE_P (parmtype))
6785         {
6786           if (! INTEGRAL_TYPE_P (argtype))
6787             return END_BUILTINS;
6788         }
6789       else
6790         return END_BUILTINS;
6791     }
6792
6793   /* Variable-length argument list.  */
6794   return DECL_FUNCTION_CODE (fndecl);
6795 }
6796
6797 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6798    evaluate to a constant.  */
6799
6800 static tree
6801 fold_builtin_constant_p (tree arg)
6802 {
6803   /* We return 1 for a numeric type that's known to be a constant
6804      value at compile-time or for an aggregate type that's a
6805      literal constant.  */
6806   STRIP_NOPS (arg);
6807
6808   /* If we know this is a constant, emit the constant of one.  */
6809   if (CONSTANT_CLASS_P (arg)
6810       || (TREE_CODE (arg) == CONSTRUCTOR
6811           && TREE_CONSTANT (arg)))
6812     return integer_one_node;
6813   if (TREE_CODE (arg) == ADDR_EXPR)
6814     {
6815        tree op = TREE_OPERAND (arg, 0);
6816        if (TREE_CODE (op) == STRING_CST
6817            || (TREE_CODE (op) == ARRAY_REF
6818                && integer_zerop (TREE_OPERAND (op, 1))
6819                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6820          return integer_one_node;
6821     }
6822
6823   /* If this expression has side effects, show we don't know it to be a
6824      constant.  Likewise if it's a pointer or aggregate type since in
6825      those case we only want literals, since those are only optimized
6826      when generating RTL, not later.
6827      And finally, if we are compiling an initializer, not code, we
6828      need to return a definite result now; there's not going to be any
6829      more optimization done.  */
6830   if (TREE_SIDE_EFFECTS (arg)
6831       || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6832       || POINTER_TYPE_P (TREE_TYPE (arg))
6833       || cfun == 0
6834       || folding_initializer)
6835     return integer_zero_node;
6836
6837   return NULL_TREE;
6838 }
6839
6840 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6841    return it as a truthvalue.  */
6842
6843 static tree
6844 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6845 {
6846   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6847
6848   fn = built_in_decls[BUILT_IN_EXPECT];
6849   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6850   ret_type = TREE_TYPE (TREE_TYPE (fn));
6851   pred_type = TREE_VALUE (arg_types);
6852   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6853
6854   pred = fold_convert_loc (loc, pred_type, pred);
6855   expected = fold_convert_loc (loc, expected_type, expected);
6856   call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6857
6858   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6859                  build_int_cst (ret_type, 0));
6860 }
6861
6862 /* Fold a call to builtin_expect with arguments ARG0 and ARG1.  Return
6863    NULL_TREE if no simplification is possible.  */
6864
6865 static tree
6866 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
6867 {
6868   tree inner, fndecl;
6869   enum tree_code code;
6870
6871   /* If this is a builtin_expect within a builtin_expect keep the
6872      inner one.  See through a comparison against a constant.  It
6873      might have been added to create a thruthvalue.  */
6874   inner = arg0;
6875   if (COMPARISON_CLASS_P (inner)
6876       && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6877     inner = TREE_OPERAND (inner, 0);
6878
6879   if (TREE_CODE (inner) == CALL_EXPR
6880       && (fndecl = get_callee_fndecl (inner))
6881       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6882       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6883     return arg0;
6884
6885   /* Distribute the expected value over short-circuiting operators.
6886      See through the cast from truthvalue_type_node to long.  */
6887   inner = arg0;
6888   while (TREE_CODE (inner) == NOP_EXPR
6889          && INTEGRAL_TYPE_P (TREE_TYPE (inner))
6890          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
6891     inner = TREE_OPERAND (inner, 0);
6892
6893   code = TREE_CODE (inner);
6894   if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6895     {
6896       tree op0 = TREE_OPERAND (inner, 0);
6897       tree op1 = TREE_OPERAND (inner, 1);
6898
6899       op0 = build_builtin_expect_predicate (loc, op0, arg1);
6900       op1 = build_builtin_expect_predicate (loc, op1, arg1);
6901       inner = build2 (code, TREE_TYPE (inner), op0, op1);
6902
6903       return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6904     }
6905
6906   /* If the argument isn't invariant then there's nothing else we can do.  */
6907   if (!TREE_CONSTANT (arg0))
6908     return NULL_TREE;
6909
6910   /* If we expect that a comparison against the argument will fold to
6911      a constant return the constant.  In practice, this means a true
6912      constant or the address of a non-weak symbol.  */
6913   inner = arg0;
6914   STRIP_NOPS (inner);
6915   if (TREE_CODE (inner) == ADDR_EXPR)
6916     {
6917       do
6918         {
6919           inner = TREE_OPERAND (inner, 0);
6920         }
6921       while (TREE_CODE (inner) == COMPONENT_REF
6922              || TREE_CODE (inner) == ARRAY_REF);
6923       if ((TREE_CODE (inner) == VAR_DECL
6924            || TREE_CODE (inner) == FUNCTION_DECL)
6925           && DECL_WEAK (inner))
6926         return NULL_TREE;
6927     }
6928
6929   /* Otherwise, ARG0 already has the proper type for the return value.  */
6930   return arg0;
6931 }
6932
6933 /* Fold a call to __builtin_classify_type with argument ARG.  */
6934
6935 static tree
6936 fold_builtin_classify_type (tree arg)
6937 {
6938   if (arg == 0)
6939     return build_int_cst (NULL_TREE, no_type_class);
6940
6941   return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
6942 }
6943
6944 /* Fold a call to __builtin_strlen with argument ARG.  */
6945
6946 static tree
6947 fold_builtin_strlen (location_t loc, tree arg)
6948 {
6949   if (!validate_arg (arg, POINTER_TYPE))
6950     return NULL_TREE;
6951   else
6952     {
6953       tree len = c_strlen (arg, 0);
6954
6955       if (len)
6956         {
6957           /* Convert from the internal "sizetype" type to "size_t".  */
6958           if (size_type_node)
6959             len = fold_convert_loc (loc, size_type_node, len);
6960           return len;
6961         }
6962
6963       return NULL_TREE;
6964     }
6965 }
6966
6967 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
6968
6969 static tree
6970 fold_builtin_inf (location_t loc, tree type, int warn)
6971 {
6972   REAL_VALUE_TYPE real;
6973
6974   /* __builtin_inff is intended to be usable to define INFINITY on all
6975      targets.  If an infinity is not available, INFINITY expands "to a
6976      positive constant of type float that overflows at translation
6977      time", footnote "In this case, using INFINITY will violate the
6978      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6979      Thus we pedwarn to ensure this constraint violation is
6980      diagnosed.  */
6981   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6982     pedwarn (loc, 0, "target format does not support infinity");
6983
6984   real_inf (&real);
6985   return build_real (type, real);
6986 }
6987
6988 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG.  */
6989
6990 static tree
6991 fold_builtin_nan (tree arg, tree type, int quiet)
6992 {
6993   REAL_VALUE_TYPE real;
6994   const char *str;
6995
6996   if (!validate_arg (arg, POINTER_TYPE))
6997     return NULL_TREE;
6998   str = c_getstr (arg);
6999   if (!str)
7000     return NULL_TREE;
7001
7002   if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
7003     return NULL_TREE;
7004
7005   return build_real (type, real);
7006 }
7007
7008 /* Return true if the floating point expression T has an integer value.
7009    We also allow +Inf, -Inf and NaN to be considered integer values.  */
7010
7011 static bool
7012 integer_valued_real_p (tree t)
7013 {
7014   switch (TREE_CODE (t))
7015     {
7016     case FLOAT_EXPR:
7017       return true;
7018
7019     case ABS_EXPR:
7020     case SAVE_EXPR:
7021       return integer_valued_real_p (TREE_OPERAND (t, 0));
7022
7023     case COMPOUND_EXPR:
7024     case MODIFY_EXPR:
7025     case BIND_EXPR:
7026       return integer_valued_real_p (TREE_OPERAND (t, 1));
7027
7028     case PLUS_EXPR:
7029     case MINUS_EXPR:
7030     case MULT_EXPR:
7031     case MIN_EXPR:
7032     case MAX_EXPR:
7033       return integer_valued_real_p (TREE_OPERAND (t, 0))
7034              && integer_valued_real_p (TREE_OPERAND (t, 1));
7035
7036     case COND_EXPR:
7037       return integer_valued_real_p (TREE_OPERAND (t, 1))
7038              && integer_valued_real_p (TREE_OPERAND (t, 2));
7039
7040     case REAL_CST:
7041       return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
7042
7043     case NOP_EXPR:
7044       {
7045         tree type = TREE_TYPE (TREE_OPERAND (t, 0));
7046         if (TREE_CODE (type) == INTEGER_TYPE)
7047           return true;
7048         if (TREE_CODE (type) == REAL_TYPE)
7049           return integer_valued_real_p (TREE_OPERAND (t, 0));
7050         break;
7051       }
7052
7053     case CALL_EXPR:
7054       switch (builtin_mathfn_code (t))
7055         {
7056         CASE_FLT_FN (BUILT_IN_CEIL):
7057         CASE_FLT_FN (BUILT_IN_FLOOR):
7058         CASE_FLT_FN (BUILT_IN_NEARBYINT):
7059         CASE_FLT_FN (BUILT_IN_RINT):
7060         CASE_FLT_FN (BUILT_IN_ROUND):
7061         CASE_FLT_FN (BUILT_IN_TRUNC):
7062           return true;
7063
7064         CASE_FLT_FN (BUILT_IN_FMIN):
7065         CASE_FLT_FN (BUILT_IN_FMAX):
7066           return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
7067             && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
7068
7069         default:
7070           break;
7071         }
7072       break;
7073
7074     default:
7075       break;
7076     }
7077   return false;
7078 }
7079
7080 /* FNDECL is assumed to be a builtin where truncation can be propagated
7081    across (for instance floor((double)f) == (double)floorf (f).
7082    Do the transformation for a call with argument ARG.  */
7083
7084 static tree
7085 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
7086 {
7087   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7088
7089   if (!validate_arg (arg, REAL_TYPE))
7090     return NULL_TREE;
7091
7092   /* Integer rounding functions are idempotent.  */
7093   if (fcode == builtin_mathfn_code (arg))
7094     return arg;
7095
7096   /* If argument is already integer valued, and we don't need to worry
7097      about setting errno, there's no need to perform rounding.  */
7098   if (! flag_errno_math && integer_valued_real_p (arg))
7099     return arg;
7100
7101   if (optimize)
7102     {
7103       tree arg0 = strip_float_extensions (arg);
7104       tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
7105       tree newtype = TREE_TYPE (arg0);
7106       tree decl;
7107
7108       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7109           && (decl = mathfn_built_in (newtype, fcode)))
7110         return fold_convert_loc (loc, ftype,
7111                                  build_call_expr_loc (loc, decl, 1,
7112                                                   fold_convert_loc (loc,
7113                                                                     newtype,
7114                                                                     arg0)));
7115     }
7116   return NULL_TREE;
7117 }
7118
7119 /* FNDECL is assumed to be builtin which can narrow the FP type of
7120    the argument, for instance lround((double)f) -> lroundf (f).
7121    Do the transformation for a call with argument ARG.  */
7122
7123 static tree
7124 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
7125 {
7126   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7127
7128   if (!validate_arg (arg, REAL_TYPE))
7129     return NULL_TREE;
7130
7131   /* If argument is already integer valued, and we don't need to worry
7132      about setting errno, there's no need to perform rounding.  */
7133   if (! flag_errno_math && integer_valued_real_p (arg))
7134     return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7135                         TREE_TYPE (TREE_TYPE (fndecl)), arg);
7136
7137   if (optimize)
7138     {
7139       tree ftype = TREE_TYPE (arg);
7140       tree arg0 = strip_float_extensions (arg);
7141       tree newtype = TREE_TYPE (arg0);
7142       tree decl;
7143
7144       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7145           && (decl = mathfn_built_in (newtype, fcode)))
7146         return build_call_expr_loc (loc, decl, 1,
7147                                 fold_convert_loc (loc, newtype, arg0));
7148     }
7149
7150   /* Canonicalize llround (x) to lround (x) on LP64 targets where
7151      sizeof (long long) == sizeof (long).  */
7152   if (TYPE_PRECISION (long_long_integer_type_node)
7153       == TYPE_PRECISION (long_integer_type_node))
7154     {
7155       tree newfn = NULL_TREE;
7156       switch (fcode)
7157         {
7158         CASE_FLT_FN (BUILT_IN_LLCEIL):
7159           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
7160           break;
7161
7162         CASE_FLT_FN (BUILT_IN_LLFLOOR):
7163           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
7164           break;
7165
7166         CASE_FLT_FN (BUILT_IN_LLROUND):
7167           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
7168           break;
7169
7170         CASE_FLT_FN (BUILT_IN_LLRINT):
7171           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7172           break;
7173
7174         default:
7175           break;
7176         }
7177
7178       if (newfn)
7179         {
7180           tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7181           return fold_convert_loc (loc,
7182                                    TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7183         }
7184     }
7185
7186   return NULL_TREE;
7187 }
7188
7189 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG.  TYPE is the
7190    return type.  Return NULL_TREE if no simplification can be made.  */
7191
7192 static tree
7193 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7194 {
7195   tree res;
7196
7197   if (!validate_arg (arg, COMPLEX_TYPE)
7198       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7199     return NULL_TREE;
7200
7201   /* Calculate the result when the argument is a constant.  */
7202   if (TREE_CODE (arg) == COMPLEX_CST
7203       && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7204                               type, mpfr_hypot)))
7205     return res;
7206
7207   if (TREE_CODE (arg) == COMPLEX_EXPR)
7208     {
7209       tree real = TREE_OPERAND (arg, 0);
7210       tree imag = TREE_OPERAND (arg, 1);
7211
7212       /* If either part is zero, cabs is fabs of the other.  */
7213       if (real_zerop (real))
7214         return fold_build1_loc (loc, ABS_EXPR, type, imag);
7215       if (real_zerop (imag))
7216         return fold_build1_loc (loc, ABS_EXPR, type, real);
7217
7218       /* cabs(x+xi) -> fabs(x)*sqrt(2).  */
7219       if (flag_unsafe_math_optimizations
7220           && operand_equal_p (real, imag, OEP_PURE_SAME))
7221         {
7222           const REAL_VALUE_TYPE sqrt2_trunc
7223             = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7224           STRIP_NOPS (real);
7225           return fold_build2_loc (loc, MULT_EXPR, type,
7226                               fold_build1_loc (loc, ABS_EXPR, type, real),
7227                               build_real (type, sqrt2_trunc));
7228         }
7229     }
7230
7231   /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z).  */
7232   if (TREE_CODE (arg) == NEGATE_EXPR
7233       || TREE_CODE (arg) == CONJ_EXPR)
7234     return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7235
7236   /* Don't do this when optimizing for size.  */
7237   if (flag_unsafe_math_optimizations
7238       && optimize && optimize_function_for_speed_p (cfun))
7239     {
7240       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7241
7242       if (sqrtfn != NULL_TREE)
7243         {
7244           tree rpart, ipart, result;
7245
7246           arg = builtin_save_expr (arg);
7247
7248           rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7249           ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7250
7251           rpart = builtin_save_expr (rpart);
7252           ipart = builtin_save_expr (ipart);
7253
7254           result = fold_build2_loc (loc, PLUS_EXPR, type,
7255                                 fold_build2_loc (loc, MULT_EXPR, type,
7256                                              rpart, rpart),
7257                                 fold_build2_loc (loc, MULT_EXPR, type,
7258                                              ipart, ipart));
7259
7260           return build_call_expr_loc (loc, sqrtfn, 1, result);
7261         }
7262     }
7263
7264   return NULL_TREE;
7265 }
7266
7267 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7268    Return NULL_TREE if no simplification can be made.  */
7269
7270 static tree
7271 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7272 {
7273
7274   enum built_in_function fcode;
7275   tree res;
7276
7277   if (!validate_arg (arg, REAL_TYPE))
7278     return NULL_TREE;
7279
7280   /* Calculate the result when the argument is a constant.  */
7281   if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7282     return res;
7283
7284   /* Optimize sqrt(expN(x)) = expN(x*0.5).  */
7285   fcode = builtin_mathfn_code (arg);
7286   if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7287     {
7288       tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7289       arg = fold_build2_loc (loc, MULT_EXPR, type,
7290                          CALL_EXPR_ARG (arg, 0),
7291                          build_real (type, dconsthalf));
7292       return build_call_expr_loc (loc, expfn, 1, arg);
7293     }
7294
7295   /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)).  */
7296   if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7297     {
7298       tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7299
7300       if (powfn)
7301         {
7302           tree arg0 = CALL_EXPR_ARG (arg, 0);
7303           tree tree_root;
7304           /* The inner root was either sqrt or cbrt.  */
7305           /* This was a conditional expression but it triggered a bug
7306              in Sun C 5.5.  */
7307           REAL_VALUE_TYPE dconstroot;
7308           if (BUILTIN_SQRT_P (fcode))
7309             dconstroot = dconsthalf;
7310           else
7311             dconstroot = dconst_third ();
7312
7313           /* Adjust for the outer root.  */
7314           SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7315           dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7316           tree_root = build_real (type, dconstroot);
7317           return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7318         }
7319     }
7320
7321   /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5).  */
7322   if (flag_unsafe_math_optimizations
7323       && (fcode == BUILT_IN_POW
7324           || fcode == BUILT_IN_POWF
7325           || fcode == BUILT_IN_POWL))
7326     {
7327       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7328       tree arg0 = CALL_EXPR_ARG (arg, 0);
7329       tree arg1 = CALL_EXPR_ARG (arg, 1);
7330       tree narg1;
7331       if (!tree_expr_nonnegative_p (arg0))
7332         arg0 = build1 (ABS_EXPR, type, arg0);
7333       narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7334                            build_real (type, dconsthalf));
7335       return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7336     }
7337
7338   return NULL_TREE;
7339 }
7340
7341 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7342    Return NULL_TREE if no simplification can be made.  */
7343
7344 static tree
7345 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7346 {
7347   const enum built_in_function fcode = builtin_mathfn_code (arg);
7348   tree res;
7349
7350   if (!validate_arg (arg, REAL_TYPE))
7351     return NULL_TREE;
7352
7353   /* Calculate the result when the argument is a constant.  */
7354   if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7355     return res;
7356
7357   if (flag_unsafe_math_optimizations)
7358     {
7359       /* Optimize cbrt(expN(x)) -> expN(x/3).  */
7360       if (BUILTIN_EXPONENT_P (fcode))
7361         {
7362           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7363           const REAL_VALUE_TYPE third_trunc =
7364             real_value_truncate (TYPE_MODE (type), dconst_third ());
7365           arg = fold_build2_loc (loc, MULT_EXPR, type,
7366                              CALL_EXPR_ARG (arg, 0),
7367                              build_real (type, third_trunc));
7368           return build_call_expr_loc (loc, expfn, 1, arg);
7369         }
7370
7371       /* Optimize cbrt(sqrt(x)) -> pow(x,1/6).  */
7372       if (BUILTIN_SQRT_P (fcode))
7373         {
7374           tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7375
7376           if (powfn)
7377             {
7378               tree arg0 = CALL_EXPR_ARG (arg, 0);
7379               tree tree_root;
7380               REAL_VALUE_TYPE dconstroot = dconst_third ();
7381
7382               SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7383               dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7384               tree_root = build_real (type, dconstroot);
7385               return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7386             }
7387         }
7388
7389       /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative.  */
7390       if (BUILTIN_CBRT_P (fcode))
7391         {
7392           tree arg0 = CALL_EXPR_ARG (arg, 0);
7393           if (tree_expr_nonnegative_p (arg0))
7394             {
7395               tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7396
7397               if (powfn)
7398                 {
7399                   tree tree_root;
7400                   REAL_VALUE_TYPE dconstroot;
7401
7402                   real_arithmetic (&dconstroot, MULT_EXPR,
7403                                    dconst_third_ptr (), dconst_third_ptr ());
7404                   dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7405                   tree_root = build_real (type, dconstroot);
7406                   return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7407                 }
7408             }
7409         }
7410
7411       /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative.  */
7412       if (fcode == BUILT_IN_POW
7413           || fcode == BUILT_IN_POWF
7414           || fcode == BUILT_IN_POWL)
7415         {
7416           tree arg00 = CALL_EXPR_ARG (arg, 0);
7417           tree arg01 = CALL_EXPR_ARG (arg, 1);
7418           if (tree_expr_nonnegative_p (arg00))
7419             {
7420               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7421               const REAL_VALUE_TYPE dconstroot
7422                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7423               tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7424                                          build_real (type, dconstroot));
7425               return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7426             }
7427         }
7428     }
7429   return NULL_TREE;
7430 }
7431
7432 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7433    TYPE is the type of the return value.  Return NULL_TREE if no
7434    simplification can be made.  */
7435
7436 static tree
7437 fold_builtin_cos (location_t loc,
7438                   tree arg, tree type, tree fndecl)
7439 {
7440   tree res, narg;
7441
7442   if (!validate_arg (arg, REAL_TYPE))
7443     return NULL_TREE;
7444
7445   /* Calculate the result when the argument is a constant.  */
7446   if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7447     return res;
7448
7449   /* Optimize cos(-x) into cos (x).  */
7450   if ((narg = fold_strip_sign_ops (arg)))
7451     return build_call_expr_loc (loc, fndecl, 1, narg);
7452
7453   return NULL_TREE;
7454 }
7455
7456 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7457    Return NULL_TREE if no simplification can be made.  */
7458
7459 static tree
7460 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7461 {
7462   if (validate_arg (arg, REAL_TYPE))
7463     {
7464       tree res, narg;
7465
7466       /* Calculate the result when the argument is a constant.  */
7467       if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7468         return res;
7469
7470       /* Optimize cosh(-x) into cosh (x).  */
7471       if ((narg = fold_strip_sign_ops (arg)))
7472         return build_call_expr_loc (loc, fndecl, 1, narg);
7473     }
7474
7475   return NULL_TREE;
7476 }
7477
7478 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7479    argument ARG.  TYPE is the type of the return value.  Return
7480    NULL_TREE if no simplification can be made.  */
7481
7482 static tree
7483 fold_builtin_ccos (location_t loc,
7484                    tree arg, tree type ATTRIBUTE_UNUSED, tree fndecl,
7485                    bool hyper ATTRIBUTE_UNUSED)
7486 {
7487   if (validate_arg (arg, COMPLEX_TYPE)
7488       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7489     {
7490       tree tmp;
7491
7492 #ifdef HAVE_mpc
7493       /* Calculate the result when the argument is a constant.  */
7494       if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7495         return tmp;
7496 #endif
7497
7498       /* Optimize fn(-x) into fn(x).  */
7499       if ((tmp = fold_strip_sign_ops (arg)))
7500         return build_call_expr_loc (loc, fndecl, 1, tmp);
7501     }
7502
7503   return NULL_TREE;
7504 }
7505
7506 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7507    Return NULL_TREE if no simplification can be made.  */
7508
7509 static tree
7510 fold_builtin_tan (tree arg, tree type)
7511 {
7512   enum built_in_function fcode;
7513   tree res;
7514
7515   if (!validate_arg (arg, REAL_TYPE))
7516     return NULL_TREE;
7517
7518   /* Calculate the result when the argument is a constant.  */
7519   if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7520     return res;
7521
7522   /* Optimize tan(atan(x)) = x.  */
7523   fcode = builtin_mathfn_code (arg);
7524   if (flag_unsafe_math_optimizations
7525       && (fcode == BUILT_IN_ATAN
7526           || fcode == BUILT_IN_ATANF
7527           || fcode == BUILT_IN_ATANL))
7528     return CALL_EXPR_ARG (arg, 0);
7529
7530   return NULL_TREE;
7531 }
7532
7533 /* Fold function call to builtin sincos, sincosf, or sincosl.  Return
7534    NULL_TREE if no simplification can be made.  */
7535
7536 static tree
7537 fold_builtin_sincos (location_t loc,
7538                      tree arg0, tree arg1, tree arg2)
7539 {
7540   tree type;
7541   tree res, fn, call;
7542
7543   if (!validate_arg (arg0, REAL_TYPE)
7544       || !validate_arg (arg1, POINTER_TYPE)
7545       || !validate_arg (arg2, POINTER_TYPE))
7546     return NULL_TREE;
7547
7548   type = TREE_TYPE (arg0);
7549
7550   /* Calculate the result when the argument is a constant.  */
7551   if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7552     return res;
7553
7554   /* Canonicalize sincos to cexpi.  */
7555   if (!TARGET_C99_FUNCTIONS)
7556     return NULL_TREE;
7557   fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7558   if (!fn)
7559     return NULL_TREE;
7560
7561   call = build_call_expr_loc (loc, fn, 1, arg0);
7562   call = builtin_save_expr (call);
7563
7564   return build2 (COMPOUND_EXPR, void_type_node,
7565                  build2 (MODIFY_EXPR, void_type_node,
7566                          build_fold_indirect_ref_loc (loc, arg1),
7567                          build1 (IMAGPART_EXPR, type, call)),
7568                  build2 (MODIFY_EXPR, void_type_node,
7569                          build_fold_indirect_ref_loc (loc, arg2),
7570                          build1 (REALPART_EXPR, type, call)));
7571 }
7572
7573 /* Fold function call to builtin cexp, cexpf, or cexpl.  Return
7574    NULL_TREE if no simplification can be made.  */
7575
7576 static tree
7577 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7578 {
7579   tree rtype;
7580   tree realp, imagp, ifn;
7581 #ifdef HAVE_mpc
7582   tree res;
7583 #endif
7584
7585   if (!validate_arg (arg0, COMPLEX_TYPE)
7586       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7587     return NULL_TREE;
7588
7589 #ifdef HAVE_mpc
7590   /* Calculate the result when the argument is a constant.  */
7591   if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7592     return res;
7593 #endif
7594
7595   rtype = TREE_TYPE (TREE_TYPE (arg0));
7596
7597   /* In case we can figure out the real part of arg0 and it is constant zero
7598      fold to cexpi.  */
7599   if (!TARGET_C99_FUNCTIONS)
7600     return NULL_TREE;
7601   ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7602   if (!ifn)
7603     return NULL_TREE;
7604
7605   if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7606       && real_zerop (realp))
7607     {
7608       tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7609       return build_call_expr_loc (loc, ifn, 1, narg);
7610     }
7611
7612   /* In case we can easily decompose real and imaginary parts split cexp
7613      to exp (r) * cexpi (i).  */
7614   if (flag_unsafe_math_optimizations
7615       && realp)
7616     {
7617       tree rfn, rcall, icall;
7618
7619       rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7620       if (!rfn)
7621         return NULL_TREE;
7622
7623       imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7624       if (!imagp)
7625         return NULL_TREE;
7626
7627       icall = build_call_expr_loc (loc, ifn, 1, imagp);
7628       icall = builtin_save_expr (icall);
7629       rcall = build_call_expr_loc (loc, rfn, 1, realp);
7630       rcall = builtin_save_expr (rcall);
7631       return fold_build2_loc (loc, COMPLEX_EXPR, type,
7632                           fold_build2_loc (loc, MULT_EXPR, rtype,
7633                                        rcall,
7634                                        fold_build1_loc (loc, REALPART_EXPR,
7635                                                     rtype, icall)),
7636                           fold_build2_loc (loc, MULT_EXPR, rtype,
7637                                        rcall,
7638                                        fold_build1_loc (loc, IMAGPART_EXPR,
7639                                                     rtype, icall)));
7640     }
7641
7642   return NULL_TREE;
7643 }
7644
7645 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7646    Return NULL_TREE if no simplification can be made.  */
7647
7648 static tree
7649 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7650 {
7651   if (!validate_arg (arg, REAL_TYPE))
7652     return NULL_TREE;
7653
7654   /* Optimize trunc of constant value.  */
7655   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7656     {
7657       REAL_VALUE_TYPE r, x;
7658       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7659
7660       x = TREE_REAL_CST (arg);
7661       real_trunc (&r, TYPE_MODE (type), &x);
7662       return build_real (type, r);
7663     }
7664
7665   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7666 }
7667
7668 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7669    Return NULL_TREE if no simplification can be made.  */
7670
7671 static tree
7672 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7673 {
7674   if (!validate_arg (arg, REAL_TYPE))
7675     return NULL_TREE;
7676
7677   /* Optimize floor of constant value.  */
7678   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7679     {
7680       REAL_VALUE_TYPE x;
7681
7682       x = TREE_REAL_CST (arg);
7683       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7684         {
7685           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7686           REAL_VALUE_TYPE r;
7687
7688           real_floor (&r, TYPE_MODE (type), &x);
7689           return build_real (type, r);
7690         }
7691     }
7692
7693   /* Fold floor (x) where x is nonnegative to trunc (x).  */
7694   if (tree_expr_nonnegative_p (arg))
7695     {
7696       tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7697       if (truncfn)
7698         return build_call_expr_loc (loc, truncfn, 1, arg);
7699     }
7700
7701   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7702 }
7703
7704 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7705    Return NULL_TREE if no simplification can be made.  */
7706
7707 static tree
7708 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7709 {
7710   if (!validate_arg (arg, REAL_TYPE))
7711     return NULL_TREE;
7712
7713   /* Optimize ceil of constant value.  */
7714   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7715     {
7716       REAL_VALUE_TYPE x;
7717
7718       x = TREE_REAL_CST (arg);
7719       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7720         {
7721           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7722           REAL_VALUE_TYPE r;
7723
7724           real_ceil (&r, TYPE_MODE (type), &x);
7725           return build_real (type, r);
7726         }
7727     }
7728
7729   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7730 }
7731
7732 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7733    Return NULL_TREE if no simplification can be made.  */
7734
7735 static tree
7736 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7737 {
7738   if (!validate_arg (arg, REAL_TYPE))
7739     return NULL_TREE;
7740
7741   /* Optimize round of constant value.  */
7742   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7743     {
7744       REAL_VALUE_TYPE x;
7745
7746       x = TREE_REAL_CST (arg);
7747       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7748         {
7749           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7750           REAL_VALUE_TYPE r;
7751
7752           real_round (&r, TYPE_MODE (type), &x);
7753           return build_real (type, r);
7754         }
7755     }
7756
7757   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7758 }
7759
7760 /* Fold function call to builtin lround, lroundf or lroundl (or the
7761    corresponding long long versions) and other rounding functions.  ARG
7762    is the argument to the call.  Return NULL_TREE if no simplification
7763    can be made.  */
7764
7765 static tree
7766 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7767 {
7768   if (!validate_arg (arg, REAL_TYPE))
7769     return NULL_TREE;
7770
7771   /* Optimize lround of constant value.  */
7772   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7773     {
7774       const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7775
7776       if (real_isfinite (&x))
7777         {
7778           tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7779           tree ftype = TREE_TYPE (arg);
7780           unsigned HOST_WIDE_INT lo2;
7781           HOST_WIDE_INT hi, lo;
7782           REAL_VALUE_TYPE r;
7783
7784           switch (DECL_FUNCTION_CODE (fndecl))
7785             {
7786             CASE_FLT_FN (BUILT_IN_LFLOOR):
7787             CASE_FLT_FN (BUILT_IN_LLFLOOR):
7788               real_floor (&r, TYPE_MODE (ftype), &x);
7789               break;
7790
7791             CASE_FLT_FN (BUILT_IN_LCEIL):
7792             CASE_FLT_FN (BUILT_IN_LLCEIL):
7793               real_ceil (&r, TYPE_MODE (ftype), &x);
7794               break;
7795
7796             CASE_FLT_FN (BUILT_IN_LROUND):
7797             CASE_FLT_FN (BUILT_IN_LLROUND):
7798               real_round (&r, TYPE_MODE (ftype), &x);
7799               break;
7800
7801             default:
7802               gcc_unreachable ();
7803             }
7804
7805           REAL_VALUE_TO_INT (&lo, &hi, r);
7806           if (!fit_double_type (lo, hi, &lo2, &hi, itype))
7807             return build_int_cst_wide (itype, lo2, hi);
7808         }
7809     }
7810
7811   switch (DECL_FUNCTION_CODE (fndecl))
7812     {
7813     CASE_FLT_FN (BUILT_IN_LFLOOR):
7814     CASE_FLT_FN (BUILT_IN_LLFLOOR):
7815       /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x).  */
7816       if (tree_expr_nonnegative_p (arg))
7817         return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7818                             TREE_TYPE (TREE_TYPE (fndecl)), arg);
7819       break;
7820     default:;
7821     }
7822
7823   return fold_fixed_mathfn (loc, fndecl, arg);
7824 }
7825
7826 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7827    and their long and long long variants (i.e. ffsl and ffsll).  ARG is
7828    the argument to the call.  Return NULL_TREE if no simplification can
7829    be made.  */
7830
7831 static tree
7832 fold_builtin_bitop (tree fndecl, tree arg)
7833 {
7834   if (!validate_arg (arg, INTEGER_TYPE))
7835     return NULL_TREE;
7836
7837   /* Optimize for constant argument.  */
7838   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7839     {
7840       HOST_WIDE_INT hi, width, result;
7841       unsigned HOST_WIDE_INT lo;
7842       tree type;
7843
7844       type = TREE_TYPE (arg);
7845       width = TYPE_PRECISION (type);
7846       lo = TREE_INT_CST_LOW (arg);
7847
7848       /* Clear all the bits that are beyond the type's precision.  */
7849       if (width > HOST_BITS_PER_WIDE_INT)
7850         {
7851           hi = TREE_INT_CST_HIGH (arg);
7852           if (width < 2 * HOST_BITS_PER_WIDE_INT)
7853             hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7854         }
7855       else
7856         {
7857           hi = 0;
7858           if (width < HOST_BITS_PER_WIDE_INT)
7859             lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7860         }
7861
7862       switch (DECL_FUNCTION_CODE (fndecl))
7863         {
7864         CASE_INT_FN (BUILT_IN_FFS):
7865           if (lo != 0)
7866             result = exact_log2 (lo & -lo) + 1;
7867           else if (hi != 0)
7868             result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi) + 1;
7869           else
7870             result = 0;
7871           break;
7872
7873         CASE_INT_FN (BUILT_IN_CLZ):
7874           if (hi != 0)
7875             result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7876           else if (lo != 0)
7877             result = width - floor_log2 (lo) - 1;
7878           else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7879             result = width;
7880           break;
7881
7882         CASE_INT_FN (BUILT_IN_CTZ):
7883           if (lo != 0)
7884             result = exact_log2 (lo & -lo);
7885           else if (hi != 0)
7886             result = HOST_BITS_PER_WIDE_INT + exact_log2 (hi & -hi);
7887           else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7888             result = width;
7889           break;
7890
7891         CASE_INT_FN (BUILT_IN_POPCOUNT):
7892           result = 0;
7893           while (lo)
7894             result++, lo &= lo - 1;
7895           while (hi)
7896             result++, hi &= hi - 1;
7897           break;
7898
7899         CASE_INT_FN (BUILT_IN_PARITY):
7900           result = 0;
7901           while (lo)
7902             result++, lo &= lo - 1;
7903           while (hi)
7904             result++, hi &= hi - 1;
7905           result &= 1;
7906           break;
7907
7908         default:
7909           gcc_unreachable ();
7910         }
7911
7912       return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7913     }
7914
7915   return NULL_TREE;
7916 }
7917
7918 /* Fold function call to builtin_bswap and the long and long long
7919    variants.  Return NULL_TREE if no simplification can be made.  */
7920 static tree
7921 fold_builtin_bswap (tree fndecl, tree arg)
7922 {
7923   if (! validate_arg (arg, INTEGER_TYPE))
7924     return NULL_TREE;
7925
7926   /* Optimize constant value.  */
7927   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7928     {
7929       HOST_WIDE_INT hi, width, r_hi = 0;
7930       unsigned HOST_WIDE_INT lo, r_lo = 0;
7931       tree type;
7932
7933       type = TREE_TYPE (arg);
7934       width = TYPE_PRECISION (type);
7935       lo = TREE_INT_CST_LOW (arg);
7936       hi = TREE_INT_CST_HIGH (arg);
7937
7938       switch (DECL_FUNCTION_CODE (fndecl))
7939         {
7940           case BUILT_IN_BSWAP32:
7941           case BUILT_IN_BSWAP64:
7942             {
7943               int s;
7944
7945               for (s = 0; s < width; s += 8)
7946                 {
7947                   int d = width - s - 8;
7948                   unsigned HOST_WIDE_INT byte;
7949
7950                   if (s < HOST_BITS_PER_WIDE_INT)
7951                     byte = (lo >> s) & 0xff;
7952                   else
7953                     byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
7954
7955                   if (d < HOST_BITS_PER_WIDE_INT)
7956                     r_lo |= byte << d;
7957                   else
7958                     r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
7959                 }
7960             }
7961
7962             break;
7963
7964         default:
7965           gcc_unreachable ();
7966         }
7967
7968       if (width < HOST_BITS_PER_WIDE_INT)
7969         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
7970       else
7971         return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
7972     }
7973
7974   return NULL_TREE;
7975 }
7976
7977 /* A subroutine of fold_builtin to fold the various logarithmic
7978    functions.  Return NULL_TREE if no simplification can me made.
7979    FUNC is the corresponding MPFR logarithm function.  */
7980
7981 static tree
7982 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
7983                         int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
7984 {
7985   if (validate_arg (arg, REAL_TYPE))
7986     {
7987       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7988       tree res;
7989       const enum built_in_function fcode = builtin_mathfn_code (arg);
7990
7991       /* Calculate the result when the argument is a constant.  */
7992       if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
7993         return res;
7994
7995       /* Special case, optimize logN(expN(x)) = x.  */
7996       if (flag_unsafe_math_optimizations
7997           && ((func == mpfr_log
7998                && (fcode == BUILT_IN_EXP
7999                    || fcode == BUILT_IN_EXPF
8000                    || fcode == BUILT_IN_EXPL))
8001               || (func == mpfr_log2
8002                   && (fcode == BUILT_IN_EXP2
8003                       || fcode == BUILT_IN_EXP2F
8004                       || fcode == BUILT_IN_EXP2L))
8005               || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
8006         return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8007
8008       /* Optimize logN(func()) for various exponential functions.  We
8009          want to determine the value "x" and the power "exponent" in
8010          order to transform logN(x**exponent) into exponent*logN(x).  */
8011       if (flag_unsafe_math_optimizations)
8012         {
8013           tree exponent = 0, x = 0;
8014
8015           switch (fcode)
8016           {
8017           CASE_FLT_FN (BUILT_IN_EXP):
8018             /* Prepare to do logN(exp(exponent) -> exponent*logN(e).  */
8019             x = build_real (type, real_value_truncate (TYPE_MODE (type),
8020                                                        dconst_e ()));
8021             exponent = CALL_EXPR_ARG (arg, 0);
8022             break;
8023           CASE_FLT_FN (BUILT_IN_EXP2):
8024             /* Prepare to do logN(exp2(exponent) -> exponent*logN(2).  */
8025             x = build_real (type, dconst2);
8026             exponent = CALL_EXPR_ARG (arg, 0);
8027             break;
8028           CASE_FLT_FN (BUILT_IN_EXP10):
8029           CASE_FLT_FN (BUILT_IN_POW10):
8030             /* Prepare to do logN(exp10(exponent) -> exponent*logN(10).  */
8031             {
8032               REAL_VALUE_TYPE dconst10;
8033               real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
8034               x = build_real (type, dconst10);
8035             }
8036             exponent = CALL_EXPR_ARG (arg, 0);
8037             break;
8038           CASE_FLT_FN (BUILT_IN_SQRT):
8039             /* Prepare to do logN(sqrt(x) -> 0.5*logN(x).  */
8040             x = CALL_EXPR_ARG (arg, 0);
8041             exponent = build_real (type, dconsthalf);
8042             break;
8043           CASE_FLT_FN (BUILT_IN_CBRT):
8044             /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x).  */
8045             x = CALL_EXPR_ARG (arg, 0);
8046             exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
8047                                                               dconst_third ()));
8048             break;
8049           CASE_FLT_FN (BUILT_IN_POW):
8050             /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x).  */
8051             x = CALL_EXPR_ARG (arg, 0);
8052             exponent = CALL_EXPR_ARG (arg, 1);
8053             break;
8054           default:
8055             break;
8056           }
8057
8058           /* Now perform the optimization.  */
8059           if (x && exponent)
8060             {
8061               tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
8062               return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
8063             }
8064         }
8065     }
8066
8067   return NULL_TREE;
8068 }
8069
8070 /* Fold a builtin function call to hypot, hypotf, or hypotl.  Return
8071    NULL_TREE if no simplification can be made.  */
8072
8073 static tree
8074 fold_builtin_hypot (location_t loc, tree fndecl,
8075                     tree arg0, tree arg1, tree type)
8076 {
8077   tree res, narg0, narg1;
8078
8079   if (!validate_arg (arg0, REAL_TYPE)
8080       || !validate_arg (arg1, REAL_TYPE))
8081     return NULL_TREE;
8082
8083   /* Calculate the result when the argument is a constant.  */
8084   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
8085     return res;
8086
8087   /* If either argument to hypot has a negate or abs, strip that off.
8088      E.g. hypot(-x,fabs(y)) -> hypot(x,y).  */
8089   narg0 = fold_strip_sign_ops (arg0);
8090   narg1 = fold_strip_sign_ops (arg1);
8091   if (narg0 || narg1)
8092     {
8093       return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
8094                               narg1 ? narg1 : arg1);
8095     }
8096
8097   /* If either argument is zero, hypot is fabs of the other.  */
8098   if (real_zerop (arg0))
8099     return fold_build1_loc (loc, ABS_EXPR, type, arg1);
8100   else if (real_zerop (arg1))
8101     return fold_build1_loc (loc, ABS_EXPR, type, arg0);
8102
8103   /* hypot(x,x) -> fabs(x)*sqrt(2).  */
8104   if (flag_unsafe_math_optimizations
8105       && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
8106     {
8107       const REAL_VALUE_TYPE sqrt2_trunc
8108         = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
8109       return fold_build2_loc (loc, MULT_EXPR, type,
8110                           fold_build1_loc (loc, ABS_EXPR, type, arg0),
8111                           build_real (type, sqrt2_trunc));
8112     }
8113
8114   return NULL_TREE;
8115 }
8116
8117
8118 /* Fold a builtin function call to pow, powf, or powl.  Return
8119    NULL_TREE if no simplification can be made.  */
8120 static tree
8121 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
8122 {
8123   tree res;
8124
8125   if (!validate_arg (arg0, REAL_TYPE)
8126        || !validate_arg (arg1, REAL_TYPE))
8127     return NULL_TREE;
8128
8129   /* Calculate the result when the argument is a constant.  */
8130   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8131     return res;
8132
8133   /* Optimize pow(1.0,y) = 1.0.  */
8134   if (real_onep (arg0))
8135     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8136
8137   if (TREE_CODE (arg1) == REAL_CST
8138       && !TREE_OVERFLOW (arg1))
8139     {
8140       REAL_VALUE_TYPE cint;
8141       REAL_VALUE_TYPE c;
8142       HOST_WIDE_INT n;
8143
8144       c = TREE_REAL_CST (arg1);
8145
8146       /* Optimize pow(x,0.0) = 1.0.  */
8147       if (REAL_VALUES_EQUAL (c, dconst0))
8148         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8149                                  arg0);
8150
8151       /* Optimize pow(x,1.0) = x.  */
8152       if (REAL_VALUES_EQUAL (c, dconst1))
8153         return arg0;
8154
8155       /* Optimize pow(x,-1.0) = 1.0/x.  */
8156       if (REAL_VALUES_EQUAL (c, dconstm1))
8157         return fold_build2_loc (loc, RDIV_EXPR, type,
8158                             build_real (type, dconst1), arg0);
8159
8160       /* Optimize pow(x,0.5) = sqrt(x).  */
8161       if (flag_unsafe_math_optimizations
8162           && REAL_VALUES_EQUAL (c, dconsthalf))
8163         {
8164           tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8165
8166           if (sqrtfn != NULL_TREE)
8167             return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8168         }
8169
8170       /* Optimize pow(x,1.0/3.0) = cbrt(x).  */
8171       if (flag_unsafe_math_optimizations)
8172         {
8173           const REAL_VALUE_TYPE dconstroot
8174             = real_value_truncate (TYPE_MODE (type), dconst_third ());
8175
8176           if (REAL_VALUES_EQUAL (c, dconstroot))
8177             {
8178               tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8179               if (cbrtfn != NULL_TREE)
8180                 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8181             }
8182         }
8183
8184       /* Check for an integer exponent.  */
8185       n = real_to_integer (&c);
8186       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8187       if (real_identical (&c, &cint))
8188         {
8189           /* Attempt to evaluate pow at compile-time, unless this should
8190              raise an exception.  */
8191           if (TREE_CODE (arg0) == REAL_CST
8192               && !TREE_OVERFLOW (arg0)
8193               && (n > 0
8194                   || (!flag_trapping_math && !flag_errno_math)
8195                   || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8196             {
8197               REAL_VALUE_TYPE x;
8198               bool inexact;
8199
8200               x = TREE_REAL_CST (arg0);
8201               inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8202               if (flag_unsafe_math_optimizations || !inexact)
8203                 return build_real (type, x);
8204             }
8205
8206           /* Strip sign ops from even integer powers.  */
8207           if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8208             {
8209               tree narg0 = fold_strip_sign_ops (arg0);
8210               if (narg0)
8211                 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8212             }
8213         }
8214     }
8215
8216   if (flag_unsafe_math_optimizations)
8217     {
8218       const enum built_in_function fcode = builtin_mathfn_code (arg0);
8219
8220       /* Optimize pow(expN(x),y) = expN(x*y).  */
8221       if (BUILTIN_EXPONENT_P (fcode))
8222         {
8223           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8224           tree arg = CALL_EXPR_ARG (arg0, 0);
8225           arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8226           return build_call_expr_loc (loc, expfn, 1, arg);
8227         }
8228
8229       /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
8230       if (BUILTIN_SQRT_P (fcode))
8231         {
8232           tree narg0 = CALL_EXPR_ARG (arg0, 0);
8233           tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8234                                     build_real (type, dconsthalf));
8235           return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8236         }
8237
8238       /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative.  */
8239       if (BUILTIN_CBRT_P (fcode))
8240         {
8241           tree arg = CALL_EXPR_ARG (arg0, 0);
8242           if (tree_expr_nonnegative_p (arg))
8243             {
8244               const REAL_VALUE_TYPE dconstroot
8245                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8246               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8247                                         build_real (type, dconstroot));
8248               return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8249             }
8250         }
8251
8252       /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative.  */
8253       if (fcode == BUILT_IN_POW
8254           || fcode == BUILT_IN_POWF
8255           || fcode == BUILT_IN_POWL)
8256         {
8257           tree arg00 = CALL_EXPR_ARG (arg0, 0);
8258           if (tree_expr_nonnegative_p (arg00))
8259             {
8260               tree arg01 = CALL_EXPR_ARG (arg0, 1);
8261               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8262               return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8263             }
8264         }
8265     }
8266
8267   return NULL_TREE;
8268 }
8269
8270 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8271    Return NULL_TREE if no simplification can be made.  */
8272 static tree
8273 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8274                    tree arg0, tree arg1, tree type)
8275 {
8276   if (!validate_arg (arg0, REAL_TYPE)
8277       || !validate_arg (arg1, INTEGER_TYPE))
8278     return NULL_TREE;
8279
8280   /* Optimize pow(1.0,y) = 1.0.  */
8281   if (real_onep (arg0))
8282     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8283
8284   if (host_integerp (arg1, 0))
8285     {
8286       HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8287
8288       /* Evaluate powi at compile-time.  */
8289       if (TREE_CODE (arg0) == REAL_CST
8290           && !TREE_OVERFLOW (arg0))
8291         {
8292           REAL_VALUE_TYPE x;
8293           x = TREE_REAL_CST (arg0);
8294           real_powi (&x, TYPE_MODE (type), &x, c);
8295           return build_real (type, x);
8296         }
8297
8298       /* Optimize pow(x,0) = 1.0.  */
8299       if (c == 0)
8300         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8301                                  arg0);
8302
8303       /* Optimize pow(x,1) = x.  */
8304       if (c == 1)
8305         return arg0;
8306
8307       /* Optimize pow(x,-1) = 1.0/x.  */
8308       if (c == -1)
8309         return fold_build2_loc (loc, RDIV_EXPR, type,
8310                            build_real (type, dconst1), arg0);
8311     }
8312
8313   return NULL_TREE;
8314 }
8315
8316 /* A subroutine of fold_builtin to fold the various exponent
8317    functions.  Return NULL_TREE if no simplification can be made.
8318    FUNC is the corresponding MPFR exponent function.  */
8319
8320 static tree
8321 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8322                        int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8323 {
8324   if (validate_arg (arg, REAL_TYPE))
8325     {
8326       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8327       tree res;
8328
8329       /* Calculate the result when the argument is a constant.  */
8330       if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8331         return res;
8332
8333       /* Optimize expN(logN(x)) = x.  */
8334       if (flag_unsafe_math_optimizations)
8335         {
8336           const enum built_in_function fcode = builtin_mathfn_code (arg);
8337
8338           if ((func == mpfr_exp
8339                && (fcode == BUILT_IN_LOG
8340                    || fcode == BUILT_IN_LOGF
8341                    || fcode == BUILT_IN_LOGL))
8342               || (func == mpfr_exp2
8343                   && (fcode == BUILT_IN_LOG2
8344                       || fcode == BUILT_IN_LOG2F
8345                       || fcode == BUILT_IN_LOG2L))
8346               || (func == mpfr_exp10
8347                   && (fcode == BUILT_IN_LOG10
8348                       || fcode == BUILT_IN_LOG10F
8349                       || fcode == BUILT_IN_LOG10L)))
8350             return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8351         }
8352     }
8353
8354   return NULL_TREE;
8355 }
8356
8357 /* Return true if VAR is a VAR_DECL or a component thereof.  */
8358
8359 static bool
8360 var_decl_component_p (tree var)
8361 {
8362   tree inner = var;
8363   while (handled_component_p (inner))
8364     inner = TREE_OPERAND (inner, 0);
8365   return SSA_VAR_P (inner);
8366 }
8367
8368 /* Fold function call to builtin memset.  Return
8369    NULL_TREE if no simplification can be made.  */
8370
8371 static tree
8372 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8373                      tree type, bool ignore)
8374 {
8375   tree var, ret, etype;
8376   unsigned HOST_WIDE_INT length, cval;
8377
8378   if (! validate_arg (dest, POINTER_TYPE)
8379       || ! validate_arg (c, INTEGER_TYPE)
8380       || ! validate_arg (len, INTEGER_TYPE))
8381     return NULL_TREE;
8382
8383   if (! host_integerp (len, 1))
8384     return NULL_TREE;
8385
8386   /* If the LEN parameter is zero, return DEST.  */
8387   if (integer_zerop (len))
8388     return omit_one_operand_loc (loc, type, dest, c);
8389
8390   if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
8391     return NULL_TREE;
8392
8393   var = dest;
8394   STRIP_NOPS (var);
8395   if (TREE_CODE (var) != ADDR_EXPR)
8396     return NULL_TREE;
8397
8398   var = TREE_OPERAND (var, 0);
8399   if (TREE_THIS_VOLATILE (var))
8400     return NULL_TREE;
8401
8402   etype = TREE_TYPE (var);
8403   if (TREE_CODE (etype) == ARRAY_TYPE)
8404     etype = TREE_TYPE (etype);
8405
8406   if (!INTEGRAL_TYPE_P (etype)
8407       && !POINTER_TYPE_P (etype))
8408     return NULL_TREE;
8409
8410   if (! var_decl_component_p (var))
8411     return NULL_TREE;
8412
8413   length = tree_low_cst (len, 1);
8414   if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8415       || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8416          < (int) length)
8417     return NULL_TREE;
8418
8419   if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8420     return NULL_TREE;
8421
8422   if (integer_zerop (c))
8423     cval = 0;
8424   else
8425     {
8426       if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8427         return NULL_TREE;
8428
8429       cval = tree_low_cst (c, 1);
8430       cval &= 0xff;
8431       cval |= cval << 8;
8432       cval |= cval << 16;
8433       cval |= (cval << 31) << 1;
8434     }
8435
8436   ret = build_int_cst_type (etype, cval);
8437   var = build_fold_indirect_ref_loc (loc,
8438                                  fold_convert_loc (loc,
8439                                                    build_pointer_type (etype),
8440                                                    dest));
8441   ret = build2 (MODIFY_EXPR, etype, var, ret);
8442   if (ignore)
8443     return ret;
8444
8445   return omit_one_operand_loc (loc, type, dest, ret);
8446 }
8447
8448 /* Fold function call to builtin memset.  Return
8449    NULL_TREE if no simplification can be made.  */
8450
8451 static tree
8452 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8453 {
8454   if (! validate_arg (dest, POINTER_TYPE)
8455       || ! validate_arg (size, INTEGER_TYPE))
8456     return NULL_TREE;
8457
8458   if (!ignore)
8459     return NULL_TREE;
8460
8461   /* New argument list transforming bzero(ptr x, int y) to
8462      memset(ptr x, int 0, size_t y).   This is done this way
8463      so that if it isn't expanded inline, we fallback to
8464      calling bzero instead of memset.  */
8465
8466   return fold_builtin_memset (loc, dest, integer_zero_node,
8467                               fold_convert_loc (loc, sizetype, size),
8468                               void_type_node, ignore);
8469 }
8470
8471 /* Fold function call to builtin mem{{,p}cpy,move}.  Return
8472    NULL_TREE if no simplification can be made.
8473    If ENDP is 0, return DEST (like memcpy).
8474    If ENDP is 1, return DEST+LEN (like mempcpy).
8475    If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8476    If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8477    (memmove).   */
8478
8479 static tree
8480 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8481                         tree len, tree type, bool ignore, int endp)
8482 {
8483   tree destvar, srcvar, expr;
8484
8485   if (! validate_arg (dest, POINTER_TYPE)
8486       || ! validate_arg (src, POINTER_TYPE)
8487       || ! validate_arg (len, INTEGER_TYPE))
8488     return NULL_TREE;
8489
8490   /* If the LEN parameter is zero, return DEST.  */
8491   if (integer_zerop (len))
8492     return omit_one_operand_loc (loc, type, dest, src);
8493
8494   /* If SRC and DEST are the same (and not volatile), return
8495      DEST{,+LEN,+LEN-1}.  */
8496   if (operand_equal_p (src, dest, 0))
8497     expr = len;
8498   else
8499     {
8500       tree srctype, desttype;
8501       int src_align, dest_align;
8502
8503       if (endp == 3)
8504         {
8505           src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8506           dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8507
8508           /* Both DEST and SRC must be pointer types.
8509              ??? This is what old code did.  Is the testing for pointer types
8510              really mandatory?
8511
8512              If either SRC is readonly or length is 1, we can use memcpy.  */
8513           if (!dest_align || !src_align)
8514             return NULL_TREE;
8515           if (readonly_data_expr (src)
8516               || (host_integerp (len, 1)
8517                   && (MIN (src_align, dest_align) / BITS_PER_UNIT
8518                       >= tree_low_cst (len, 1))))
8519             {
8520               tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8521               if (!fn)
8522                 return NULL_TREE;
8523               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8524             }
8525
8526           /* If *src and *dest can't overlap, optimize into memcpy as well.  */
8527           srcvar = build_fold_indirect_ref_loc (loc, src);
8528           destvar = build_fold_indirect_ref_loc (loc, dest);
8529           if (srcvar
8530               && !TREE_THIS_VOLATILE (srcvar)
8531               && destvar
8532               && !TREE_THIS_VOLATILE (destvar))
8533             {
8534               tree src_base, dest_base, fn;
8535               HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8536               HOST_WIDE_INT size = -1;
8537               HOST_WIDE_INT maxsize = -1;
8538
8539               src_base = srcvar;
8540               if (handled_component_p (src_base))
8541                 src_base = get_ref_base_and_extent (src_base, &src_offset,
8542                                                     &size, &maxsize);
8543               dest_base = destvar;
8544               if (handled_component_p (dest_base))
8545                 dest_base = get_ref_base_and_extent (dest_base, &dest_offset,
8546                                                      &size, &maxsize);
8547               if (host_integerp (len, 1))
8548                 {
8549                   maxsize = tree_low_cst (len, 1);
8550                   if (maxsize
8551                       > INTTYPE_MAXIMUM (HOST_WIDE_INT) / BITS_PER_UNIT)
8552                     maxsize = -1;
8553                   else
8554                     maxsize *= BITS_PER_UNIT;
8555                 }
8556               else
8557                 maxsize = -1;
8558               if (SSA_VAR_P (src_base)
8559                   && SSA_VAR_P (dest_base))
8560                 {
8561                   if (operand_equal_p (src_base, dest_base, 0)
8562                       && ranges_overlap_p (src_offset, maxsize,
8563                                            dest_offset, maxsize))
8564                     return NULL_TREE;
8565                 }
8566               else if (TREE_CODE (src_base) == INDIRECT_REF
8567                        && TREE_CODE (dest_base) == INDIRECT_REF)
8568                 {
8569                   if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8570                                          TREE_OPERAND (dest_base, 0), 0)
8571                       || ranges_overlap_p (src_offset, maxsize,
8572                                            dest_offset, maxsize))
8573                     return NULL_TREE;
8574                 }
8575               else
8576                 return NULL_TREE;
8577
8578               fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8579               if (!fn)
8580                 return NULL_TREE;
8581               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8582             }
8583           return NULL_TREE;
8584         }
8585
8586       if (!host_integerp (len, 0))
8587         return NULL_TREE;
8588       /* FIXME:
8589          This logic lose for arguments like (type *)malloc (sizeof (type)),
8590          since we strip the casts of up to VOID return value from malloc.
8591          Perhaps we ought to inherit type from non-VOID argument here?  */
8592       STRIP_NOPS (src);
8593       STRIP_NOPS (dest);
8594       /* As we fold (void *)(p + CST) to (void *)p + CST undo this here.  */
8595       if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8596         {
8597           tree tem = TREE_OPERAND (src, 0);
8598           STRIP_NOPS (tem);
8599           if (tem != TREE_OPERAND (src, 0))
8600             src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8601         }
8602       if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8603         {
8604           tree tem = TREE_OPERAND (dest, 0);
8605           STRIP_NOPS (tem);
8606           if (tem != TREE_OPERAND (dest, 0))
8607             dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8608         }
8609       srctype = TREE_TYPE (TREE_TYPE (src));
8610       if (srctype
8611           && TREE_CODE (srctype) == ARRAY_TYPE
8612           && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8613         {
8614           srctype = TREE_TYPE (srctype);
8615           STRIP_NOPS (src);
8616           src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8617         }
8618       desttype = TREE_TYPE (TREE_TYPE (dest));
8619       if (desttype
8620           && TREE_CODE (desttype) == ARRAY_TYPE
8621           && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8622         {
8623           desttype = TREE_TYPE (desttype);
8624           STRIP_NOPS (dest);
8625           dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8626         }
8627       if (!srctype || !desttype
8628           || !TYPE_SIZE_UNIT (srctype)
8629           || !TYPE_SIZE_UNIT (desttype)
8630           || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
8631           || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST
8632           || TYPE_VOLATILE (srctype)
8633           || TYPE_VOLATILE (desttype))
8634         return NULL_TREE;
8635
8636       src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8637       dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8638       if (dest_align < (int) TYPE_ALIGN (desttype)
8639           || src_align < (int) TYPE_ALIGN (srctype))
8640         return NULL_TREE;
8641
8642       if (!ignore)
8643         dest = builtin_save_expr (dest);
8644
8645       srcvar = NULL_TREE;
8646       if (tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8647         {
8648           srcvar = build_fold_indirect_ref_loc (loc, src);
8649           if (TREE_THIS_VOLATILE (srcvar))
8650             return NULL_TREE;
8651           else if (!tree_int_cst_equal (tree_expr_size (srcvar), len))
8652             srcvar = NULL_TREE;
8653           /* With memcpy, it is possible to bypass aliasing rules, so without
8654              this check i.e. execute/20060930-2.c would be misoptimized,
8655              because it use conflicting alias set to hold argument for the
8656              memcpy call.  This check is probably unnecessary with
8657              -fno-strict-aliasing.  Similarly for destvar.  See also
8658              PR29286.  */
8659           else if (!var_decl_component_p (srcvar))
8660             srcvar = NULL_TREE;
8661         }
8662
8663       destvar = NULL_TREE;
8664       if (tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8665         {
8666           destvar = build_fold_indirect_ref_loc (loc, dest);
8667           if (TREE_THIS_VOLATILE (destvar))
8668             return NULL_TREE;
8669           else if (!tree_int_cst_equal (tree_expr_size (destvar), len))
8670             destvar = NULL_TREE;
8671           else if (!var_decl_component_p (destvar))
8672             destvar = NULL_TREE;
8673         }
8674
8675       if (srcvar == NULL_TREE && destvar == NULL_TREE)
8676         return NULL_TREE;
8677
8678       if (srcvar == NULL_TREE)
8679         {
8680           tree srcptype;
8681           if (TREE_ADDRESSABLE (TREE_TYPE (destvar)))
8682             return NULL_TREE;
8683
8684           srctype = build_qualified_type (desttype, 0);
8685           if (src_align < (int) TYPE_ALIGN (srctype))
8686             {
8687               if (AGGREGATE_TYPE_P (srctype)
8688                   || SLOW_UNALIGNED_ACCESS (TYPE_MODE (srctype), src_align))
8689                 return NULL_TREE;
8690
8691               srctype = build_variant_type_copy (srctype);
8692               TYPE_ALIGN (srctype) = src_align;
8693               TYPE_USER_ALIGN (srctype) = 1;
8694               TYPE_PACKED (srctype) = 1;
8695             }
8696           srcptype = build_pointer_type_for_mode (srctype, ptr_mode, true);
8697           src = fold_convert_loc (loc, srcptype, src);
8698           srcvar = build_fold_indirect_ref_loc (loc, src);
8699         }
8700       else if (destvar == NULL_TREE)
8701         {
8702           tree destptype;
8703           if (TREE_ADDRESSABLE (TREE_TYPE (srcvar)))
8704             return NULL_TREE;
8705
8706           desttype = build_qualified_type (srctype, 0);
8707           if (dest_align < (int) TYPE_ALIGN (desttype))
8708             {
8709               if (AGGREGATE_TYPE_P (desttype)
8710                   || SLOW_UNALIGNED_ACCESS (TYPE_MODE (desttype), dest_align))
8711                 return NULL_TREE;
8712
8713               desttype = build_variant_type_copy (desttype);
8714               TYPE_ALIGN (desttype) = dest_align;
8715               TYPE_USER_ALIGN (desttype) = 1;
8716               TYPE_PACKED (desttype) = 1;
8717             }
8718           destptype = build_pointer_type_for_mode (desttype, ptr_mode, true);
8719           dest = fold_convert_loc (loc, destptype, dest);
8720           destvar = build_fold_indirect_ref_loc (loc, dest);
8721         }
8722
8723       if (srctype == desttype
8724           || (gimple_in_ssa_p (cfun)
8725               && useless_type_conversion_p (desttype, srctype)))
8726         expr = srcvar;
8727       else if ((INTEGRAL_TYPE_P (TREE_TYPE (srcvar))
8728            || POINTER_TYPE_P (TREE_TYPE (srcvar)))
8729           && (INTEGRAL_TYPE_P (TREE_TYPE (destvar))
8730               || POINTER_TYPE_P (TREE_TYPE (destvar))))
8731         expr = fold_convert_loc (loc, TREE_TYPE (destvar), srcvar);
8732       else
8733         expr = fold_build1_loc (loc, VIEW_CONVERT_EXPR,
8734                             TREE_TYPE (destvar), srcvar);
8735       expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, expr);
8736     }
8737
8738   if (ignore)
8739     return expr;
8740
8741   if (endp == 0 || endp == 3)
8742     return omit_one_operand_loc (loc, type, dest, expr);
8743
8744   if (expr == len)
8745     expr = NULL_TREE;
8746
8747   if (endp == 2)
8748     len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
8749                        ssize_int (1));
8750
8751   len = fold_convert_loc (loc, sizetype, len);
8752   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8753   dest = fold_convert_loc (loc, type, dest);
8754   if (expr)
8755     dest = omit_one_operand_loc (loc, type, dest, expr);
8756   return dest;
8757 }
8758
8759 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8760    If LEN is not NULL, it represents the length of the string to be
8761    copied.  Return NULL_TREE if no simplification can be made.  */
8762
8763 tree
8764 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
8765 {
8766   tree fn;
8767
8768   if (!validate_arg (dest, POINTER_TYPE)
8769       || !validate_arg (src, POINTER_TYPE))
8770     return NULL_TREE;
8771
8772   /* If SRC and DEST are the same (and not volatile), return DEST.  */
8773   if (operand_equal_p (src, dest, 0))
8774     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
8775
8776   if (optimize_function_for_size_p (cfun))
8777     return NULL_TREE;
8778
8779   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8780   if (!fn)
8781     return NULL_TREE;
8782
8783   if (!len)
8784     {
8785       len = c_strlen (src, 1);
8786       if (! len || TREE_SIDE_EFFECTS (len))
8787         return NULL_TREE;
8788     }
8789
8790   len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8791   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8792                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8793 }
8794
8795 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
8796    Return NULL_TREE if no simplification can be made.  */
8797
8798 static tree
8799 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
8800 {
8801   tree fn, len, lenp1, call, type;
8802
8803   if (!validate_arg (dest, POINTER_TYPE)
8804       || !validate_arg (src, POINTER_TYPE))
8805     return NULL_TREE;
8806
8807   len = c_strlen (src, 1);
8808   if (!len
8809       || TREE_CODE (len) != INTEGER_CST)
8810     return NULL_TREE;
8811
8812   if (optimize_function_for_size_p (cfun)
8813       /* If length is zero it's small enough.  */
8814       && !integer_zerop (len))
8815     return NULL_TREE;
8816
8817   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8818   if (!fn)
8819     return NULL_TREE;
8820
8821   lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8822   /* We use dest twice in building our expression.  Save it from
8823      multiple expansions.  */
8824   dest = builtin_save_expr (dest);
8825   call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
8826
8827   type = TREE_TYPE (TREE_TYPE (fndecl));
8828   len = fold_convert_loc (loc, sizetype, len);
8829   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8830   dest = fold_convert_loc (loc, type, dest);
8831   dest = omit_one_operand_loc (loc, type, dest, call);
8832   return dest;
8833 }
8834
8835 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8836    If SLEN is not NULL, it represents the length of the source string.
8837    Return NULL_TREE if no simplification can be made.  */
8838
8839 tree
8840 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
8841                       tree src, tree len, tree slen)
8842 {
8843   tree fn;
8844
8845   if (!validate_arg (dest, POINTER_TYPE)
8846       || !validate_arg (src, POINTER_TYPE)
8847       || !validate_arg (len, INTEGER_TYPE))
8848     return NULL_TREE;
8849
8850   /* If the LEN parameter is zero, return DEST.  */
8851   if (integer_zerop (len))
8852     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8853
8854   /* We can't compare slen with len as constants below if len is not a
8855      constant.  */
8856   if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8857     return NULL_TREE;
8858
8859   if (!slen)
8860     slen = c_strlen (src, 1);
8861
8862   /* Now, we must be passed a constant src ptr parameter.  */
8863   if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8864     return NULL_TREE;
8865
8866   slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
8867
8868   /* We do not support simplification of this case, though we do
8869      support it when expanding trees into RTL.  */
8870   /* FIXME: generate a call to __builtin_memset.  */
8871   if (tree_int_cst_lt (slen, len))
8872     return NULL_TREE;
8873
8874   /* OK transform into builtin memcpy.  */
8875   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8876   if (!fn)
8877     return NULL_TREE;
8878   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8879                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8880 }
8881
8882 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
8883    arguments to the call, and TYPE is its return type.
8884    Return NULL_TREE if no simplification can be made.  */
8885
8886 static tree
8887 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
8888 {
8889   if (!validate_arg (arg1, POINTER_TYPE)
8890       || !validate_arg (arg2, INTEGER_TYPE)
8891       || !validate_arg (len, INTEGER_TYPE))
8892     return NULL_TREE;
8893   else
8894     {
8895       const char *p1;
8896
8897       if (TREE_CODE (arg2) != INTEGER_CST
8898           || !host_integerp (len, 1))
8899         return NULL_TREE;
8900
8901       p1 = c_getstr (arg1);
8902       if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
8903         {
8904           char c;
8905           const char *r;
8906           tree tem;
8907
8908           if (target_char_cast (arg2, &c))
8909             return NULL_TREE;
8910
8911           r = (char *) memchr (p1, c, tree_low_cst (len, 1));
8912
8913           if (r == NULL)
8914             return build_int_cst (TREE_TYPE (arg1), 0);
8915
8916           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
8917                              size_int (r - p1));
8918           return fold_convert_loc (loc, type, tem);
8919         }
8920       return NULL_TREE;
8921     }
8922 }
8923
8924 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8925    Return NULL_TREE if no simplification can be made.  */
8926
8927 static tree
8928 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
8929 {
8930   const char *p1, *p2;
8931
8932   if (!validate_arg (arg1, POINTER_TYPE)
8933       || !validate_arg (arg2, POINTER_TYPE)
8934       || !validate_arg (len, INTEGER_TYPE))
8935     return NULL_TREE;
8936
8937   /* If the LEN parameter is zero, return zero.  */
8938   if (integer_zerop (len))
8939     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8940                               arg1, arg2);
8941
8942   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8943   if (operand_equal_p (arg1, arg2, 0))
8944     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8945
8946   p1 = c_getstr (arg1);
8947   p2 = c_getstr (arg2);
8948
8949   /* If all arguments are constant, and the value of len is not greater
8950      than the lengths of arg1 and arg2, evaluate at compile-time.  */
8951   if (host_integerp (len, 1) && p1 && p2
8952       && compare_tree_int (len, strlen (p1) + 1) <= 0
8953       && compare_tree_int (len, strlen (p2) + 1) <= 0)
8954     {
8955       const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8956
8957       if (r > 0)
8958         return integer_one_node;
8959       else if (r < 0)
8960         return integer_minus_one_node;
8961       else
8962         return integer_zero_node;
8963     }
8964
8965   /* If len parameter is one, return an expression corresponding to
8966      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
8967   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8968     {
8969       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8970       tree cst_uchar_ptr_node
8971         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8972
8973       tree ind1
8974         = fold_convert_loc (loc, integer_type_node,
8975                             build1 (INDIRECT_REF, cst_uchar_node,
8976                                     fold_convert_loc (loc,
8977                                                       cst_uchar_ptr_node,
8978                                                       arg1)));
8979       tree ind2
8980         = fold_convert_loc (loc, integer_type_node,
8981                             build1 (INDIRECT_REF, cst_uchar_node,
8982                                     fold_convert_loc (loc,
8983                                                       cst_uchar_ptr_node,
8984                                                       arg2)));
8985       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8986     }
8987
8988   return NULL_TREE;
8989 }
8990
8991 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8992    Return NULL_TREE if no simplification can be made.  */
8993
8994 static tree
8995 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
8996 {
8997   const char *p1, *p2;
8998
8999   if (!validate_arg (arg1, POINTER_TYPE)
9000       || !validate_arg (arg2, POINTER_TYPE))
9001     return NULL_TREE;
9002
9003   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
9004   if (operand_equal_p (arg1, arg2, 0))
9005     return integer_zero_node;
9006
9007   p1 = c_getstr (arg1);
9008   p2 = c_getstr (arg2);
9009
9010   if (p1 && p2)
9011     {
9012       const int i = strcmp (p1, p2);
9013       if (i < 0)
9014         return integer_minus_one_node;
9015       else if (i > 0)
9016         return integer_one_node;
9017       else
9018         return integer_zero_node;
9019     }
9020
9021   /* If the second arg is "", return *(const unsigned char*)arg1.  */
9022   if (p2 && *p2 == '\0')
9023     {
9024       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9025       tree cst_uchar_ptr_node
9026         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9027
9028       return fold_convert_loc (loc, integer_type_node,
9029                                build1 (INDIRECT_REF, cst_uchar_node,
9030                                        fold_convert_loc (loc,
9031                                                          cst_uchar_ptr_node,
9032                                                          arg1)));
9033     }
9034
9035   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
9036   if (p1 && *p1 == '\0')
9037     {
9038       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9039       tree cst_uchar_ptr_node
9040         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9041
9042       tree temp
9043         = fold_convert_loc (loc, integer_type_node,
9044                             build1 (INDIRECT_REF, cst_uchar_node,
9045                                     fold_convert_loc (loc,
9046                                                       cst_uchar_ptr_node,
9047                                                       arg2)));
9048       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9049     }
9050
9051   return NULL_TREE;
9052 }
9053
9054 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
9055    Return NULL_TREE if no simplification can be made.  */
9056
9057 static tree
9058 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
9059 {
9060   const char *p1, *p2;
9061
9062   if (!validate_arg (arg1, POINTER_TYPE)
9063       || !validate_arg (arg2, POINTER_TYPE)
9064       || !validate_arg (len, INTEGER_TYPE))
9065     return NULL_TREE;
9066
9067   /* If the LEN parameter is zero, return zero.  */
9068   if (integer_zerop (len))
9069     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
9070                               arg1, arg2);
9071
9072   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
9073   if (operand_equal_p (arg1, arg2, 0))
9074     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
9075
9076   p1 = c_getstr (arg1);
9077   p2 = c_getstr (arg2);
9078
9079   if (host_integerp (len, 1) && p1 && p2)
9080     {
9081       const int i = strncmp (p1, p2, tree_low_cst (len, 1));
9082       if (i > 0)
9083         return integer_one_node;
9084       else if (i < 0)
9085         return integer_minus_one_node;
9086       else
9087         return integer_zero_node;
9088     }
9089
9090   /* If the second arg is "", and the length is greater than zero,
9091      return *(const unsigned char*)arg1.  */
9092   if (p2 && *p2 == '\0'
9093       && TREE_CODE (len) == INTEGER_CST
9094       && tree_int_cst_sgn (len) == 1)
9095     {
9096       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9097       tree cst_uchar_ptr_node
9098         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9099
9100       return fold_convert_loc (loc, integer_type_node,
9101                                build1 (INDIRECT_REF, cst_uchar_node,
9102                                        fold_convert_loc (loc,
9103                                                          cst_uchar_ptr_node,
9104                                                          arg1)));
9105     }
9106
9107   /* If the first arg is "", and the length is greater than zero,
9108      return -*(const unsigned char*)arg2.  */
9109   if (p1 && *p1 == '\0'
9110       && TREE_CODE (len) == INTEGER_CST
9111       && tree_int_cst_sgn (len) == 1)
9112     {
9113       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9114       tree cst_uchar_ptr_node
9115         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9116
9117       tree temp = fold_convert_loc (loc, integer_type_node,
9118                                     build1 (INDIRECT_REF, cst_uchar_node,
9119                                             fold_convert_loc (loc,
9120                                                               cst_uchar_ptr_node,
9121                                                               arg2)));
9122       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9123     }
9124
9125   /* If len parameter is one, return an expression corresponding to
9126      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
9127   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9128     {
9129       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9130       tree cst_uchar_ptr_node
9131         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9132
9133       tree ind1 = fold_convert_loc (loc, integer_type_node,
9134                                     build1 (INDIRECT_REF, cst_uchar_node,
9135                                             fold_convert_loc (loc,
9136                                                               cst_uchar_ptr_node,
9137                                                               arg1)));
9138       tree ind2 = fold_convert_loc (loc, integer_type_node,
9139                                     build1 (INDIRECT_REF, cst_uchar_node,
9140                                             fold_convert_loc (loc,
9141                                                               cst_uchar_ptr_node,
9142                                                               arg2)));
9143       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9144     }
9145
9146   return NULL_TREE;
9147 }
9148
9149 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9150    ARG.  Return NULL_TREE if no simplification can be made.  */
9151
9152 static tree
9153 fold_builtin_signbit (location_t loc, tree arg, tree type)
9154 {
9155   tree temp;
9156
9157   if (!validate_arg (arg, REAL_TYPE))
9158     return NULL_TREE;
9159
9160   /* If ARG is a compile-time constant, determine the result.  */
9161   if (TREE_CODE (arg) == REAL_CST
9162       && !TREE_OVERFLOW (arg))
9163     {
9164       REAL_VALUE_TYPE c;
9165
9166       c = TREE_REAL_CST (arg);
9167       temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
9168       return fold_convert_loc (loc, type, temp);
9169     }
9170
9171   /* If ARG is non-negative, the result is always zero.  */
9172   if (tree_expr_nonnegative_p (arg))
9173     return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9174
9175   /* If ARG's format doesn't have signed zeros, return "arg < 0.0".  */
9176   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9177     return fold_build2_loc (loc, LT_EXPR, type, arg,
9178                         build_real (TREE_TYPE (arg), dconst0));
9179
9180   return NULL_TREE;
9181 }
9182
9183 /* Fold function call to builtin copysign, copysignf or copysignl with
9184    arguments ARG1 and ARG2.  Return NULL_TREE if no simplification can
9185    be made.  */
9186
9187 static tree
9188 fold_builtin_copysign (location_t loc, tree fndecl,
9189                        tree arg1, tree arg2, tree type)
9190 {
9191   tree tem;
9192
9193   if (!validate_arg (arg1, REAL_TYPE)
9194       || !validate_arg (arg2, REAL_TYPE))
9195     return NULL_TREE;
9196
9197   /* copysign(X,X) is X.  */
9198   if (operand_equal_p (arg1, arg2, 0))
9199     return fold_convert_loc (loc, type, arg1);
9200
9201   /* If ARG1 and ARG2 are compile-time constants, determine the result.  */
9202   if (TREE_CODE (arg1) == REAL_CST
9203       && TREE_CODE (arg2) == REAL_CST
9204       && !TREE_OVERFLOW (arg1)
9205       && !TREE_OVERFLOW (arg2))
9206     {
9207       REAL_VALUE_TYPE c1, c2;
9208
9209       c1 = TREE_REAL_CST (arg1);
9210       c2 = TREE_REAL_CST (arg2);
9211       /* c1.sign := c2.sign.  */
9212       real_copysign (&c1, &c2);
9213       return build_real (type, c1);
9214     }
9215
9216   /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9217      Remember to evaluate Y for side-effects.  */
9218   if (tree_expr_nonnegative_p (arg2))
9219     return omit_one_operand_loc (loc, type,
9220                              fold_build1_loc (loc, ABS_EXPR, type, arg1),
9221                              arg2);
9222
9223   /* Strip sign changing operations for the first argument.  */
9224   tem = fold_strip_sign_ops (arg1);
9225   if (tem)
9226     return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9227
9228   return NULL_TREE;
9229 }
9230
9231 /* Fold a call to builtin isascii with argument ARG.  */
9232
9233 static tree
9234 fold_builtin_isascii (location_t loc, tree arg)
9235 {
9236   if (!validate_arg (arg, INTEGER_TYPE))
9237     return NULL_TREE;
9238   else
9239     {
9240       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
9241       arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9242                          build_int_cst (NULL_TREE,
9243                                         ~ (unsigned HOST_WIDE_INT) 0x7f));
9244       return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9245                           arg, integer_zero_node);
9246     }
9247 }
9248
9249 /* Fold a call to builtin toascii with argument ARG.  */
9250
9251 static tree
9252 fold_builtin_toascii (location_t loc, tree arg)
9253 {
9254   if (!validate_arg (arg, INTEGER_TYPE))
9255     return NULL_TREE;
9256
9257   /* Transform toascii(c) -> (c & 0x7f).  */
9258   return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9259                       build_int_cst (NULL_TREE, 0x7f));
9260 }
9261
9262 /* Fold a call to builtin isdigit with argument ARG.  */
9263
9264 static tree
9265 fold_builtin_isdigit (location_t loc, tree arg)
9266 {
9267   if (!validate_arg (arg, INTEGER_TYPE))
9268     return NULL_TREE;
9269   else
9270     {
9271       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
9272       /* According to the C standard, isdigit is unaffected by locale.
9273          However, it definitely is affected by the target character set.  */
9274       unsigned HOST_WIDE_INT target_digit0
9275         = lang_hooks.to_target_charset ('0');
9276
9277       if (target_digit0 == 0)
9278         return NULL_TREE;
9279
9280       arg = fold_convert_loc (loc, unsigned_type_node, arg);
9281       arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9282                          build_int_cst (unsigned_type_node, target_digit0));
9283       return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9284                           build_int_cst (unsigned_type_node, 9));
9285     }
9286 }
9287
9288 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
9289
9290 static tree
9291 fold_builtin_fabs (location_t loc, tree arg, tree type)
9292 {
9293   if (!validate_arg (arg, REAL_TYPE))
9294     return NULL_TREE;
9295
9296   arg = fold_convert_loc (loc, type, arg);
9297   if (TREE_CODE (arg) == REAL_CST)
9298     return fold_abs_const (arg, type);
9299   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9300 }
9301
9302 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
9303
9304 static tree
9305 fold_builtin_abs (location_t loc, tree arg, tree type)
9306 {
9307   if (!validate_arg (arg, INTEGER_TYPE))
9308     return NULL_TREE;
9309
9310   arg = fold_convert_loc (loc, type, arg);
9311   if (TREE_CODE (arg) == INTEGER_CST)
9312     return fold_abs_const (arg, type);
9313   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9314 }
9315
9316 /* Fold a call to builtin fmin or fmax.  */
9317
9318 static tree
9319 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9320                         tree type, bool max)
9321 {
9322   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9323     {
9324       /* Calculate the result when the argument is a constant.  */
9325       tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9326
9327       if (res)
9328         return res;
9329
9330       /* If either argument is NaN, return the other one.  Avoid the
9331          transformation if we get (and honor) a signalling NaN.  Using
9332          omit_one_operand() ensures we create a non-lvalue.  */
9333       if (TREE_CODE (arg0) == REAL_CST
9334           && real_isnan (&TREE_REAL_CST (arg0))
9335           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9336               || ! TREE_REAL_CST (arg0).signalling))
9337         return omit_one_operand_loc (loc, type, arg1, arg0);
9338       if (TREE_CODE (arg1) == REAL_CST
9339           && real_isnan (&TREE_REAL_CST (arg1))
9340           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9341               || ! TREE_REAL_CST (arg1).signalling))
9342         return omit_one_operand_loc (loc, type, arg0, arg1);
9343
9344       /* Transform fmin/fmax(x,x) -> x.  */
9345       if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9346         return omit_one_operand_loc (loc, type, arg0, arg1);
9347
9348       /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR.  C99 requires these
9349          functions to return the numeric arg if the other one is NaN.
9350          These tree codes don't honor that, so only transform if
9351          -ffinite-math-only is set.  C99 doesn't require -0.0 to be
9352          handled, so we don't have to worry about it either.  */
9353       if (flag_finite_math_only)
9354         return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9355                             fold_convert_loc (loc, type, arg0),
9356                             fold_convert_loc (loc, type, arg1));
9357     }
9358   return NULL_TREE;
9359 }
9360
9361 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
9362
9363 static tree
9364 fold_builtin_carg (location_t loc, tree arg, tree type)
9365 {
9366   if (validate_arg (arg, COMPLEX_TYPE)
9367       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9368     {
9369       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9370
9371       if (atan2_fn)
9372         {
9373           tree new_arg = builtin_save_expr (arg);
9374           tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9375           tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9376           return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9377         }
9378     }
9379
9380   return NULL_TREE;
9381 }
9382
9383 /* Fold a call to builtin logb/ilogb.  */
9384
9385 static tree
9386 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9387 {
9388   if (! validate_arg (arg, REAL_TYPE))
9389     return NULL_TREE;
9390
9391   STRIP_NOPS (arg);
9392
9393   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9394     {
9395       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9396
9397       switch (value->cl)
9398       {
9399       case rvc_nan:
9400       case rvc_inf:
9401         /* If arg is Inf or NaN and we're logb, return it.  */
9402         if (TREE_CODE (rettype) == REAL_TYPE)
9403           return fold_convert_loc (loc, rettype, arg);
9404         /* Fall through... */
9405       case rvc_zero:
9406         /* Zero may set errno and/or raise an exception for logb, also
9407            for ilogb we don't know FP_ILOGB0.  */
9408         return NULL_TREE;
9409       case rvc_normal:
9410         /* For normal numbers, proceed iff radix == 2.  In GCC,
9411            normalized significands are in the range [0.5, 1.0).  We
9412            want the exponent as if they were [1.0, 2.0) so get the
9413            exponent and subtract 1.  */
9414         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9415           return fold_convert_loc (loc, rettype,
9416                                    build_int_cst (NULL_TREE,
9417                                                   REAL_EXP (value)-1));
9418         break;
9419       }
9420     }
9421
9422   return NULL_TREE;
9423 }
9424
9425 /* Fold a call to builtin significand, if radix == 2.  */
9426
9427 static tree
9428 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9429 {
9430   if (! validate_arg (arg, REAL_TYPE))
9431     return NULL_TREE;
9432
9433   STRIP_NOPS (arg);
9434
9435   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9436     {
9437       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9438
9439       switch (value->cl)
9440       {
9441       case rvc_zero:
9442       case rvc_nan:
9443       case rvc_inf:
9444         /* If arg is +-0, +-Inf or +-NaN, then return it.  */
9445         return fold_convert_loc (loc, rettype, arg);
9446       case rvc_normal:
9447         /* For normal numbers, proceed iff radix == 2.  */
9448         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9449           {
9450             REAL_VALUE_TYPE result = *value;
9451             /* In GCC, normalized significands are in the range [0.5,
9452                1.0).  We want them to be [1.0, 2.0) so set the
9453                exponent to 1.  */
9454             SET_REAL_EXP (&result, 1);
9455             return build_real (rettype, result);
9456           }
9457         break;
9458       }
9459     }
9460
9461   return NULL_TREE;
9462 }
9463
9464 /* Fold a call to builtin frexp, we can assume the base is 2.  */
9465
9466 static tree
9467 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9468 {
9469   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9470     return NULL_TREE;
9471
9472   STRIP_NOPS (arg0);
9473
9474   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9475     return NULL_TREE;
9476
9477   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9478
9479   /* Proceed if a valid pointer type was passed in.  */
9480   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9481     {
9482       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9483       tree frac, exp;
9484
9485       switch (value->cl)
9486       {
9487       case rvc_zero:
9488         /* For +-0, return (*exp = 0, +-0).  */
9489         exp = integer_zero_node;
9490         frac = arg0;
9491         break;
9492       case rvc_nan:
9493       case rvc_inf:
9494         /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
9495         return omit_one_operand_loc (loc, rettype, arg0, arg1);
9496       case rvc_normal:
9497         {
9498           /* Since the frexp function always expects base 2, and in
9499              GCC normalized significands are already in the range
9500              [0.5, 1.0), we have exactly what frexp wants.  */
9501           REAL_VALUE_TYPE frac_rvt = *value;
9502           SET_REAL_EXP (&frac_rvt, 0);
9503           frac = build_real (rettype, frac_rvt);
9504           exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9505         }
9506         break;
9507       default:
9508         gcc_unreachable ();
9509       }
9510
9511       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9512       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9513       TREE_SIDE_EFFECTS (arg1) = 1;
9514       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9515     }
9516
9517   return NULL_TREE;
9518 }
9519
9520 /* Fold a call to builtin ldexp or scalbn/scalbln.  If LDEXP is true
9521    then we can assume the base is two.  If it's false, then we have to
9522    check the mode of the TYPE parameter in certain cases.  */
9523
9524 static tree
9525 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9526                             tree type, bool ldexp)
9527 {
9528   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9529     {
9530       STRIP_NOPS (arg0);
9531       STRIP_NOPS (arg1);
9532
9533       /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0.  */
9534       if (real_zerop (arg0) || integer_zerop (arg1)
9535           || (TREE_CODE (arg0) == REAL_CST
9536               && !real_isfinite (&TREE_REAL_CST (arg0))))
9537         return omit_one_operand_loc (loc, type, arg0, arg1);
9538
9539       /* If both arguments are constant, then try to evaluate it.  */
9540       if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9541           && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9542           && host_integerp (arg1, 0))
9543         {
9544           /* Bound the maximum adjustment to twice the range of the
9545              mode's valid exponents.  Use abs to ensure the range is
9546              positive as a sanity check.  */
9547           const long max_exp_adj = 2 *
9548             labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9549                  - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9550
9551           /* Get the user-requested adjustment.  */
9552           const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9553
9554           /* The requested adjustment must be inside this range.  This
9555              is a preliminary cap to avoid things like overflow, we
9556              may still fail to compute the result for other reasons.  */
9557           if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9558             {
9559               REAL_VALUE_TYPE initial_result;
9560
9561               real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9562
9563               /* Ensure we didn't overflow.  */
9564               if (! real_isinf (&initial_result))
9565                 {
9566                   const REAL_VALUE_TYPE trunc_result
9567                     = real_value_truncate (TYPE_MODE (type), initial_result);
9568
9569                   /* Only proceed if the target mode can hold the
9570                      resulting value.  */
9571                   if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9572                     return build_real (type, trunc_result);
9573                 }
9574             }
9575         }
9576     }
9577
9578   return NULL_TREE;
9579 }
9580
9581 /* Fold a call to builtin modf.  */
9582
9583 static tree
9584 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9585 {
9586   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9587     return NULL_TREE;
9588
9589   STRIP_NOPS (arg0);
9590
9591   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9592     return NULL_TREE;
9593
9594   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9595
9596   /* Proceed if a valid pointer type was passed in.  */
9597   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9598     {
9599       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9600       REAL_VALUE_TYPE trunc, frac;
9601
9602       switch (value->cl)
9603       {
9604       case rvc_nan:
9605       case rvc_zero:
9606         /* For +-NaN or +-0, return (*arg1 = arg0, arg0).  */
9607         trunc = frac = *value;
9608         break;
9609       case rvc_inf:
9610         /* For +-Inf, return (*arg1 = arg0, +-0).  */
9611         frac = dconst0;
9612         frac.sign = value->sign;
9613         trunc = *value;
9614         break;
9615       case rvc_normal:
9616         /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)).  */
9617         real_trunc (&trunc, VOIDmode, value);
9618         real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9619         /* If the original number was negative and already
9620            integral, then the fractional part is -0.0.  */
9621         if (value->sign && frac.cl == rvc_zero)
9622           frac.sign = value->sign;
9623         break;
9624       }
9625
9626       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9627       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9628                           build_real (rettype, trunc));
9629       TREE_SIDE_EFFECTS (arg1) = 1;
9630       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9631                           build_real (rettype, frac));
9632     }
9633
9634   return NULL_TREE;
9635 }
9636
9637 /* Given a location LOC, an interclass builtin function decl FNDECL
9638    and its single argument ARG, return an folded expression computing
9639    the same, or NULL_TREE if we either couldn't or didn't want to fold
9640    (the latter happen if there's an RTL instruction available).  */
9641
9642 static tree
9643 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9644 {
9645   enum machine_mode mode;
9646
9647   if (!validate_arg (arg, REAL_TYPE))
9648     return NULL_TREE;
9649
9650   if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9651     return NULL_TREE;
9652
9653   mode = TYPE_MODE (TREE_TYPE (arg));
9654
9655   /* If there is no optab, try generic code.  */
9656   switch (DECL_FUNCTION_CODE (fndecl))
9657     {
9658       tree result;
9659
9660     CASE_FLT_FN (BUILT_IN_ISINF):
9661       {
9662         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
9663         tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
9664         tree const type = TREE_TYPE (arg);
9665         REAL_VALUE_TYPE r;
9666         char buf[128];
9667
9668         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9669         real_from_string (&r, buf);
9670         result = build_call_expr (isgr_fn, 2,
9671                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9672                                   build_real (type, r));
9673         return result;
9674       }
9675     CASE_FLT_FN (BUILT_IN_FINITE):
9676     case BUILT_IN_ISFINITE:
9677       {
9678         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
9679         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9680         tree const type = TREE_TYPE (arg);
9681         REAL_VALUE_TYPE r;
9682         char buf[128];
9683
9684         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9685         real_from_string (&r, buf);
9686         result = build_call_expr (isle_fn, 2,
9687                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9688                                   build_real (type, r));
9689         /*result = fold_build2_loc (loc, UNGT_EXPR,
9690                                   TREE_TYPE (TREE_TYPE (fndecl)),
9691                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9692                                   build_real (type, r));
9693         result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9694                                   TREE_TYPE (TREE_TYPE (fndecl)),
9695                                   result);*/
9696         return result;
9697       }
9698     case BUILT_IN_ISNORMAL:
9699       {
9700         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9701            islessequal(fabs(x),DBL_MAX).  */
9702         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9703         tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
9704         tree const type = TREE_TYPE (arg);
9705         REAL_VALUE_TYPE rmax, rmin;
9706         char buf[128];
9707
9708         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9709         real_from_string (&rmax, buf);
9710         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9711         real_from_string (&rmin, buf);
9712         arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9713         result = build_call_expr (isle_fn, 2, arg,
9714                                   build_real (type, rmax));
9715         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
9716                               build_call_expr (isge_fn, 2, arg,
9717                                                build_real (type, rmin)));
9718         return result;
9719       }
9720     default:
9721       break;
9722     }
9723
9724   return NULL_TREE;
9725 }
9726
9727 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9728    ARG is the argument for the call.  */
9729
9730 static tree
9731 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
9732 {
9733   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9734   REAL_VALUE_TYPE r;
9735
9736   if (!validate_arg (arg, REAL_TYPE))
9737     return NULL_TREE;
9738
9739   switch (builtin_index)
9740     {
9741     case BUILT_IN_ISINF:
9742       if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9743         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9744
9745       if (TREE_CODE (arg) == REAL_CST)
9746         {
9747           r = TREE_REAL_CST (arg);
9748           if (real_isinf (&r))
9749             return real_compare (GT_EXPR, &r, &dconst0)
9750                    ? integer_one_node : integer_minus_one_node;
9751           else
9752             return integer_zero_node;
9753         }
9754
9755       return NULL_TREE;
9756
9757     case BUILT_IN_ISINF_SIGN:
9758       {
9759         /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9760         /* In a boolean context, GCC will fold the inner COND_EXPR to
9761            1.  So e.g. "if (isinf_sign(x))" would be folded to just
9762            "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9763         tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
9764         tree isinf_fn = built_in_decls[BUILT_IN_ISINF];
9765         tree tmp = NULL_TREE;
9766
9767         arg = builtin_save_expr (arg);
9768
9769         if (signbit_fn && isinf_fn)
9770           {
9771             tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
9772             tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
9773
9774             signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9775                                         signbit_call, integer_zero_node);
9776             isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9777                                       isinf_call, integer_zero_node);
9778
9779             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
9780                                integer_minus_one_node, integer_one_node);
9781             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9782                                isinf_call, tmp,
9783                                integer_zero_node);
9784           }
9785
9786         return tmp;
9787       }
9788
9789     case BUILT_IN_ISFINITE:
9790       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
9791           && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9792         return omit_one_operand_loc (loc, type, integer_one_node, arg);
9793
9794       if (TREE_CODE (arg) == REAL_CST)
9795         {
9796           r = TREE_REAL_CST (arg);
9797           return real_isfinite (&r) ? integer_one_node : integer_zero_node;
9798         }
9799
9800       return NULL_TREE;
9801
9802     case BUILT_IN_ISNAN:
9803       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
9804         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9805
9806       if (TREE_CODE (arg) == REAL_CST)
9807         {
9808           r = TREE_REAL_CST (arg);
9809           return real_isnan (&r) ? integer_one_node : integer_zero_node;
9810         }
9811
9812       arg = builtin_save_expr (arg);
9813       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
9814
9815     default:
9816       gcc_unreachable ();
9817     }
9818 }
9819
9820 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9821    This builtin will generate code to return the appropriate floating
9822    point classification depending on the value of the floating point
9823    number passed in.  The possible return values must be supplied as
9824    int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9825    FP_NORMAL, FP_SUBNORMAL and FP_ZERO.  The ellipses is for exactly
9826    one floating point argument which is "type generic".  */
9827
9828 static tree
9829 fold_builtin_fpclassify (location_t loc, tree exp)
9830 {
9831   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
9832     arg, type, res, tmp;
9833   enum machine_mode mode;
9834   REAL_VALUE_TYPE r;
9835   char buf[128];
9836
9837   /* Verify the required arguments in the original call.  */
9838   if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
9839                          INTEGER_TYPE, INTEGER_TYPE,
9840                          INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
9841     return NULL_TREE;
9842
9843   fp_nan = CALL_EXPR_ARG (exp, 0);
9844   fp_infinite = CALL_EXPR_ARG (exp, 1);
9845   fp_normal = CALL_EXPR_ARG (exp, 2);
9846   fp_subnormal = CALL_EXPR_ARG (exp, 3);
9847   fp_zero = CALL_EXPR_ARG (exp, 4);
9848   arg = CALL_EXPR_ARG (exp, 5);
9849   type = TREE_TYPE (arg);
9850   mode = TYPE_MODE (type);
9851   arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9852
9853   /* fpclassify(x) ->
9854        isnan(x) ? FP_NAN :
9855          (fabs(x) == Inf ? FP_INFINITE :
9856            (fabs(x) >= DBL_MIN ? FP_NORMAL :
9857              (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
9858
9859   tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9860                      build_real (type, dconst0));
9861   res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9862                      tmp, fp_zero, fp_subnormal);
9863
9864   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9865   real_from_string (&r, buf);
9866   tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
9867                      arg, build_real (type, r));
9868   res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
9869
9870   if (HONOR_INFINITIES (mode))
9871     {
9872       real_inf (&r);
9873       tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9874                          build_real (type, r));
9875       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
9876                          fp_infinite, res);
9877     }
9878
9879   if (HONOR_NANS (mode))
9880     {
9881       tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
9882       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
9883     }
9884
9885   return res;
9886 }
9887
9888 /* Fold a call to an unordered comparison function such as
9889    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
9890    being called and ARG0 and ARG1 are the arguments for the call.
9891    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9892    the opposite of the desired result.  UNORDERED_CODE is used
9893    for modes that can hold NaNs and ORDERED_CODE is used for
9894    the rest.  */
9895
9896 static tree
9897 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
9898                             enum tree_code unordered_code,
9899                             enum tree_code ordered_code)
9900 {
9901   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9902   enum tree_code code;
9903   tree type0, type1;
9904   enum tree_code code0, code1;
9905   tree cmp_type = NULL_TREE;
9906
9907   type0 = TREE_TYPE (arg0);
9908   type1 = TREE_TYPE (arg1);
9909
9910   code0 = TREE_CODE (type0);
9911   code1 = TREE_CODE (type1);
9912
9913   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
9914     /* Choose the wider of two real types.  */
9915     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
9916       ? type0 : type1;
9917   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
9918     cmp_type = type0;
9919   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
9920     cmp_type = type1;
9921
9922   arg0 = fold_convert_loc (loc, cmp_type, arg0);
9923   arg1 = fold_convert_loc (loc, cmp_type, arg1);
9924
9925   if (unordered_code == UNORDERED_EXPR)
9926     {
9927       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9928         return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
9929       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
9930     }
9931
9932   code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
9933                                                    : ordered_code;
9934   return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
9935                       fold_build2_loc (loc, code, type, arg0, arg1));
9936 }
9937
9938 /* Fold a call to built-in function FNDECL with 0 arguments.
9939    IGNORE is true if the result of the function call is ignored.  This
9940    function returns NULL_TREE if no simplification was possible.  */
9941
9942 static tree
9943 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
9944 {
9945   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9946   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9947   switch (fcode)
9948     {
9949     CASE_FLT_FN (BUILT_IN_INF):
9950     case BUILT_IN_INFD32:
9951     case BUILT_IN_INFD64:
9952     case BUILT_IN_INFD128:
9953       return fold_builtin_inf (loc, type, true);
9954
9955     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
9956       return fold_builtin_inf (loc, type, false);
9957
9958     case BUILT_IN_CLASSIFY_TYPE:
9959       return fold_builtin_classify_type (NULL_TREE);
9960
9961     default:
9962       break;
9963     }
9964   return NULL_TREE;
9965 }
9966
9967 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9968    IGNORE is true if the result of the function call is ignored.  This
9969    function returns NULL_TREE if no simplification was possible.  */
9970
9971 static tree
9972 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
9973 {
9974   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9975   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9976   switch (fcode)
9977     {
9978
9979     case BUILT_IN_CONSTANT_P:
9980       {
9981         tree val = fold_builtin_constant_p (arg0);
9982
9983         /* Gimplification will pull the CALL_EXPR for the builtin out of
9984            an if condition.  When not optimizing, we'll not CSE it back.
9985            To avoid link error types of regressions, return false now.  */
9986         if (!val && !optimize)
9987           val = integer_zero_node;
9988
9989         return val;
9990       }
9991
9992     case BUILT_IN_CLASSIFY_TYPE:
9993       return fold_builtin_classify_type (arg0);
9994
9995     case BUILT_IN_STRLEN:
9996       return fold_builtin_strlen (loc, arg0);
9997
9998     CASE_FLT_FN (BUILT_IN_FABS):
9999       return fold_builtin_fabs (loc, arg0, type);
10000
10001     case BUILT_IN_ABS:
10002     case BUILT_IN_LABS:
10003     case BUILT_IN_LLABS:
10004     case BUILT_IN_IMAXABS:
10005       return fold_builtin_abs (loc, arg0, type);
10006
10007     CASE_FLT_FN (BUILT_IN_CONJ):
10008       if (validate_arg (arg0, COMPLEX_TYPE)
10009         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10010         return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
10011     break;
10012
10013     CASE_FLT_FN (BUILT_IN_CREAL):
10014       if (validate_arg (arg0, COMPLEX_TYPE)
10015         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10016         return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
10017     break;
10018
10019     CASE_FLT_FN (BUILT_IN_CIMAG):
10020       if (validate_arg (arg0, COMPLEX_TYPE)
10021           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10022         return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
10023     break;
10024
10025     CASE_FLT_FN (BUILT_IN_CCOS):
10026       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
10027
10028     CASE_FLT_FN (BUILT_IN_CCOSH):
10029       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
10030
10031 #ifdef HAVE_mpc
10032     CASE_FLT_FN (BUILT_IN_CSIN):
10033       if (validate_arg (arg0, COMPLEX_TYPE)
10034           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10035         return do_mpc_arg1 (arg0, type, mpc_sin);
10036     break;
10037
10038     CASE_FLT_FN (BUILT_IN_CSINH):
10039       if (validate_arg (arg0, COMPLEX_TYPE)
10040           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10041         return do_mpc_arg1 (arg0, type, mpc_sinh);
10042     break;
10043
10044     CASE_FLT_FN (BUILT_IN_CTAN):
10045       if (validate_arg (arg0, COMPLEX_TYPE)
10046           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10047         return do_mpc_arg1 (arg0, type, mpc_tan);
10048     break;
10049
10050     CASE_FLT_FN (BUILT_IN_CTANH):
10051       if (validate_arg (arg0, COMPLEX_TYPE)
10052           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10053         return do_mpc_arg1 (arg0, type, mpc_tanh);
10054     break;
10055
10056     CASE_FLT_FN (BUILT_IN_CLOG):
10057       if (validate_arg (arg0, COMPLEX_TYPE)
10058           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10059         return do_mpc_arg1 (arg0, type, mpc_log);
10060     break;
10061
10062     CASE_FLT_FN (BUILT_IN_CSQRT):
10063       if (validate_arg (arg0, COMPLEX_TYPE)
10064           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10065         return do_mpc_arg1 (arg0, type, mpc_sqrt);
10066     break;
10067
10068 #ifdef HAVE_mpc_arc
10069     CASE_FLT_FN (BUILT_IN_CASIN):
10070       if (validate_arg (arg0, COMPLEX_TYPE)
10071           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10072         return do_mpc_arg1 (arg0, type, mpc_asin);
10073     break;
10074
10075     CASE_FLT_FN (BUILT_IN_CACOS):
10076       if (validate_arg (arg0, COMPLEX_TYPE)
10077           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10078         return do_mpc_arg1 (arg0, type, mpc_acos);
10079     break;
10080
10081     CASE_FLT_FN (BUILT_IN_CATAN):
10082       if (validate_arg (arg0, COMPLEX_TYPE)
10083           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10084         return do_mpc_arg1 (arg0, type, mpc_atan);
10085     break;
10086
10087     CASE_FLT_FN (BUILT_IN_CASINH):
10088       if (validate_arg (arg0, COMPLEX_TYPE)
10089           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10090         return do_mpc_arg1 (arg0, type, mpc_asinh);
10091     break;
10092
10093     CASE_FLT_FN (BUILT_IN_CACOSH):
10094       if (validate_arg (arg0, COMPLEX_TYPE)
10095           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10096         return do_mpc_arg1 (arg0, type, mpc_acosh);
10097     break;
10098
10099     CASE_FLT_FN (BUILT_IN_CATANH):
10100       if (validate_arg (arg0, COMPLEX_TYPE)
10101           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10102         return do_mpc_arg1 (arg0, type, mpc_atanh);
10103     break;
10104 #endif /* HAVE_mpc_arc */
10105 #endif /* HAVE_mpc */
10106
10107     CASE_FLT_FN (BUILT_IN_CABS):
10108       return fold_builtin_cabs (loc, arg0, type, fndecl);
10109
10110     CASE_FLT_FN (BUILT_IN_CARG):
10111       return fold_builtin_carg (loc, arg0, type);
10112
10113     CASE_FLT_FN (BUILT_IN_SQRT):
10114       return fold_builtin_sqrt (loc, arg0, type);
10115
10116     CASE_FLT_FN (BUILT_IN_CBRT):
10117       return fold_builtin_cbrt (loc, arg0, type);
10118
10119     CASE_FLT_FN (BUILT_IN_ASIN):
10120       if (validate_arg (arg0, REAL_TYPE))
10121         return do_mpfr_arg1 (arg0, type, mpfr_asin,
10122                              &dconstm1, &dconst1, true);
10123     break;
10124
10125     CASE_FLT_FN (BUILT_IN_ACOS):
10126       if (validate_arg (arg0, REAL_TYPE))
10127         return do_mpfr_arg1 (arg0, type, mpfr_acos,
10128                              &dconstm1, &dconst1, true);
10129     break;
10130
10131     CASE_FLT_FN (BUILT_IN_ATAN):
10132       if (validate_arg (arg0, REAL_TYPE))
10133         return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10134     break;
10135
10136     CASE_FLT_FN (BUILT_IN_ASINH):
10137       if (validate_arg (arg0, REAL_TYPE))
10138         return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10139     break;
10140
10141     CASE_FLT_FN (BUILT_IN_ACOSH):
10142       if (validate_arg (arg0, REAL_TYPE))
10143         return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10144                              &dconst1, NULL, true);
10145     break;
10146
10147     CASE_FLT_FN (BUILT_IN_ATANH):
10148       if (validate_arg (arg0, REAL_TYPE))
10149         return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10150                              &dconstm1, &dconst1, false);
10151     break;
10152
10153     CASE_FLT_FN (BUILT_IN_SIN):
10154       if (validate_arg (arg0, REAL_TYPE))
10155         return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10156     break;
10157
10158     CASE_FLT_FN (BUILT_IN_COS):
10159       return fold_builtin_cos (loc, arg0, type, fndecl);
10160
10161     CASE_FLT_FN (BUILT_IN_TAN):
10162       return fold_builtin_tan (arg0, type);
10163
10164     CASE_FLT_FN (BUILT_IN_CEXP):
10165       return fold_builtin_cexp (loc, arg0, type);
10166
10167     CASE_FLT_FN (BUILT_IN_CEXPI):
10168       if (validate_arg (arg0, REAL_TYPE))
10169         return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10170     break;
10171
10172     CASE_FLT_FN (BUILT_IN_SINH):
10173       if (validate_arg (arg0, REAL_TYPE))
10174         return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10175     break;
10176
10177     CASE_FLT_FN (BUILT_IN_COSH):
10178       return fold_builtin_cosh (loc, arg0, type, fndecl);
10179
10180     CASE_FLT_FN (BUILT_IN_TANH):
10181       if (validate_arg (arg0, REAL_TYPE))
10182         return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10183     break;
10184
10185     CASE_FLT_FN (BUILT_IN_ERF):
10186       if (validate_arg (arg0, REAL_TYPE))
10187         return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10188     break;
10189
10190     CASE_FLT_FN (BUILT_IN_ERFC):
10191       if (validate_arg (arg0, REAL_TYPE))
10192         return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10193     break;
10194
10195     CASE_FLT_FN (BUILT_IN_TGAMMA):
10196       if (validate_arg (arg0, REAL_TYPE))
10197         return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10198     break;
10199
10200     CASE_FLT_FN (BUILT_IN_EXP):
10201       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10202
10203     CASE_FLT_FN (BUILT_IN_EXP2):
10204       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10205
10206     CASE_FLT_FN (BUILT_IN_EXP10):
10207     CASE_FLT_FN (BUILT_IN_POW10):
10208       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10209
10210     CASE_FLT_FN (BUILT_IN_EXPM1):
10211       if (validate_arg (arg0, REAL_TYPE))
10212         return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10213     break;
10214
10215     CASE_FLT_FN (BUILT_IN_LOG):
10216     return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10217
10218     CASE_FLT_FN (BUILT_IN_LOG2):
10219       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10220
10221     CASE_FLT_FN (BUILT_IN_LOG10):
10222       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10223
10224     CASE_FLT_FN (BUILT_IN_LOG1P):
10225       if (validate_arg (arg0, REAL_TYPE))
10226         return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10227                              &dconstm1, NULL, false);
10228     break;
10229
10230     CASE_FLT_FN (BUILT_IN_J0):
10231       if (validate_arg (arg0, REAL_TYPE))
10232         return do_mpfr_arg1 (arg0, type, mpfr_j0,
10233                              NULL, NULL, 0);
10234     break;
10235
10236     CASE_FLT_FN (BUILT_IN_J1):
10237       if (validate_arg (arg0, REAL_TYPE))
10238         return do_mpfr_arg1 (arg0, type, mpfr_j1,
10239                              NULL, NULL, 0);
10240     break;
10241
10242     CASE_FLT_FN (BUILT_IN_Y0):
10243       if (validate_arg (arg0, REAL_TYPE))
10244         return do_mpfr_arg1 (arg0, type, mpfr_y0,
10245                              &dconst0, NULL, false);
10246     break;
10247
10248     CASE_FLT_FN (BUILT_IN_Y1):
10249       if (validate_arg (arg0, REAL_TYPE))
10250         return do_mpfr_arg1 (arg0, type, mpfr_y1,
10251                              &dconst0, NULL, false);
10252     break;
10253
10254     CASE_FLT_FN (BUILT_IN_NAN):
10255     case BUILT_IN_NAND32:
10256     case BUILT_IN_NAND64:
10257     case BUILT_IN_NAND128:
10258       return fold_builtin_nan (arg0, type, true);
10259
10260     CASE_FLT_FN (BUILT_IN_NANS):
10261       return fold_builtin_nan (arg0, type, false);
10262
10263     CASE_FLT_FN (BUILT_IN_FLOOR):
10264       return fold_builtin_floor (loc, fndecl, arg0);
10265
10266     CASE_FLT_FN (BUILT_IN_CEIL):
10267       return fold_builtin_ceil (loc, fndecl, arg0);
10268
10269     CASE_FLT_FN (BUILT_IN_TRUNC):
10270       return fold_builtin_trunc (loc, fndecl, arg0);
10271
10272     CASE_FLT_FN (BUILT_IN_ROUND):
10273       return fold_builtin_round (loc, fndecl, arg0);
10274
10275     CASE_FLT_FN (BUILT_IN_NEARBYINT):
10276     CASE_FLT_FN (BUILT_IN_RINT):
10277       return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10278
10279     CASE_FLT_FN (BUILT_IN_LCEIL):
10280     CASE_FLT_FN (BUILT_IN_LLCEIL):
10281     CASE_FLT_FN (BUILT_IN_LFLOOR):
10282     CASE_FLT_FN (BUILT_IN_LLFLOOR):
10283     CASE_FLT_FN (BUILT_IN_LROUND):
10284     CASE_FLT_FN (BUILT_IN_LLROUND):
10285       return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10286
10287     CASE_FLT_FN (BUILT_IN_LRINT):
10288     CASE_FLT_FN (BUILT_IN_LLRINT):
10289       return fold_fixed_mathfn (loc, fndecl, arg0);
10290
10291     case BUILT_IN_BSWAP32:
10292     case BUILT_IN_BSWAP64:
10293       return fold_builtin_bswap (fndecl, arg0);
10294
10295     CASE_INT_FN (BUILT_IN_FFS):
10296     CASE_INT_FN (BUILT_IN_CLZ):
10297     CASE_INT_FN (BUILT_IN_CTZ):
10298     CASE_INT_FN (BUILT_IN_POPCOUNT):
10299     CASE_INT_FN (BUILT_IN_PARITY):
10300       return fold_builtin_bitop (fndecl, arg0);
10301
10302     CASE_FLT_FN (BUILT_IN_SIGNBIT):
10303       return fold_builtin_signbit (loc, arg0, type);
10304
10305     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10306       return fold_builtin_significand (loc, arg0, type);
10307
10308     CASE_FLT_FN (BUILT_IN_ILOGB):
10309     CASE_FLT_FN (BUILT_IN_LOGB):
10310       return fold_builtin_logb (loc, arg0, type);
10311
10312     case BUILT_IN_ISASCII:
10313       return fold_builtin_isascii (loc, arg0);
10314
10315     case BUILT_IN_TOASCII:
10316       return fold_builtin_toascii (loc, arg0);
10317
10318     case BUILT_IN_ISDIGIT:
10319       return fold_builtin_isdigit (loc, arg0);
10320
10321     CASE_FLT_FN (BUILT_IN_FINITE):
10322     case BUILT_IN_FINITED32:
10323     case BUILT_IN_FINITED64:
10324     case BUILT_IN_FINITED128:
10325     case BUILT_IN_ISFINITE:
10326       {
10327         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10328         if (ret)
10329           return ret;
10330         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10331       }
10332
10333     CASE_FLT_FN (BUILT_IN_ISINF):
10334     case BUILT_IN_ISINFD32:
10335     case BUILT_IN_ISINFD64:
10336     case BUILT_IN_ISINFD128:
10337       {
10338         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10339         if (ret)
10340           return ret;
10341         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10342       }
10343
10344     case BUILT_IN_ISNORMAL:
10345       return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10346
10347     case BUILT_IN_ISINF_SIGN:
10348       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10349
10350     CASE_FLT_FN (BUILT_IN_ISNAN):
10351     case BUILT_IN_ISNAND32:
10352     case BUILT_IN_ISNAND64:
10353     case BUILT_IN_ISNAND128:
10354       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10355
10356     case BUILT_IN_PRINTF:
10357     case BUILT_IN_PRINTF_UNLOCKED:
10358     case BUILT_IN_VPRINTF:
10359       return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10360
10361     default:
10362       break;
10363     }
10364
10365   return NULL_TREE;
10366
10367 }
10368
10369 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10370    IGNORE is true if the result of the function call is ignored.  This
10371    function returns NULL_TREE if no simplification was possible.  */
10372
10373 static tree
10374 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10375 {
10376   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10377   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10378
10379   switch (fcode)
10380     {
10381     CASE_FLT_FN (BUILT_IN_JN):
10382       if (validate_arg (arg0, INTEGER_TYPE)
10383           && validate_arg (arg1, REAL_TYPE))
10384         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10385     break;
10386
10387     CASE_FLT_FN (BUILT_IN_YN):
10388       if (validate_arg (arg0, INTEGER_TYPE)
10389           && validate_arg (arg1, REAL_TYPE))
10390         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10391                                  &dconst0, false);
10392     break;
10393
10394     CASE_FLT_FN (BUILT_IN_DREM):
10395     CASE_FLT_FN (BUILT_IN_REMAINDER):
10396       if (validate_arg (arg0, REAL_TYPE)
10397           && validate_arg(arg1, REAL_TYPE))
10398         return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10399     break;
10400
10401     CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10402     CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10403       if (validate_arg (arg0, REAL_TYPE)
10404           && validate_arg(arg1, POINTER_TYPE))
10405         return do_mpfr_lgamma_r (arg0, arg1, type);
10406     break;
10407
10408     CASE_FLT_FN (BUILT_IN_ATAN2):
10409       if (validate_arg (arg0, REAL_TYPE)
10410           && validate_arg(arg1, REAL_TYPE))
10411         return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10412     break;
10413
10414     CASE_FLT_FN (BUILT_IN_FDIM):
10415       if (validate_arg (arg0, REAL_TYPE)
10416           && validate_arg(arg1, REAL_TYPE))
10417         return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10418     break;
10419
10420     CASE_FLT_FN (BUILT_IN_HYPOT):
10421       return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10422
10423 #ifdef HAVE_mpc_pow
10424     CASE_FLT_FN (BUILT_IN_CPOW):
10425       if (validate_arg (arg0, COMPLEX_TYPE)
10426           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10427           && validate_arg (arg1, COMPLEX_TYPE)
10428           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10429         return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10430     break;
10431 #endif
10432
10433     CASE_FLT_FN (BUILT_IN_LDEXP):
10434       return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10435     CASE_FLT_FN (BUILT_IN_SCALBN):
10436     CASE_FLT_FN (BUILT_IN_SCALBLN):
10437       return fold_builtin_load_exponent (loc, arg0, arg1,
10438                                          type, /*ldexp=*/false);
10439
10440     CASE_FLT_FN (BUILT_IN_FREXP):
10441       return fold_builtin_frexp (loc, arg0, arg1, type);
10442
10443     CASE_FLT_FN (BUILT_IN_MODF):
10444       return fold_builtin_modf (loc, arg0, arg1, type);
10445
10446     case BUILT_IN_BZERO:
10447       return fold_builtin_bzero (loc, arg0, arg1, ignore);
10448
10449     case BUILT_IN_FPUTS:
10450       return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10451
10452     case BUILT_IN_FPUTS_UNLOCKED:
10453       return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10454
10455     case BUILT_IN_STRSTR:
10456       return fold_builtin_strstr (loc, arg0, arg1, type);
10457
10458     case BUILT_IN_STRCAT:
10459       return fold_builtin_strcat (loc, arg0, arg1);
10460
10461     case BUILT_IN_STRSPN:
10462       return fold_builtin_strspn (loc, arg0, arg1);
10463
10464     case BUILT_IN_STRCSPN:
10465       return fold_builtin_strcspn (loc, arg0, arg1);
10466
10467     case BUILT_IN_STRCHR:
10468     case BUILT_IN_INDEX:
10469       return fold_builtin_strchr (loc, arg0, arg1, type);
10470
10471     case BUILT_IN_STRRCHR:
10472     case BUILT_IN_RINDEX:
10473       return fold_builtin_strrchr (loc, arg0, arg1, type);
10474
10475     case BUILT_IN_STRCPY:
10476       return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10477
10478     case BUILT_IN_STPCPY:
10479       if (ignore)
10480         {
10481           tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
10482           if (!fn)
10483             break;
10484
10485           return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10486         }
10487       else
10488         return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10489       break;
10490
10491     case BUILT_IN_STRCMP:
10492       return fold_builtin_strcmp (loc, arg0, arg1);
10493
10494     case BUILT_IN_STRPBRK:
10495       return fold_builtin_strpbrk (loc, arg0, arg1, type);
10496
10497     case BUILT_IN_EXPECT:
10498       return fold_builtin_expect (loc, arg0, arg1);
10499
10500     CASE_FLT_FN (BUILT_IN_POW):
10501       return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10502
10503     CASE_FLT_FN (BUILT_IN_POWI):
10504       return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10505
10506     CASE_FLT_FN (BUILT_IN_COPYSIGN):
10507       return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10508
10509     CASE_FLT_FN (BUILT_IN_FMIN):
10510       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10511
10512     CASE_FLT_FN (BUILT_IN_FMAX):
10513       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10514
10515     case BUILT_IN_ISGREATER:
10516       return fold_builtin_unordered_cmp (loc, fndecl,
10517                                          arg0, arg1, UNLE_EXPR, LE_EXPR);
10518     case BUILT_IN_ISGREATEREQUAL:
10519       return fold_builtin_unordered_cmp (loc, fndecl,
10520                                          arg0, arg1, UNLT_EXPR, LT_EXPR);
10521     case BUILT_IN_ISLESS:
10522       return fold_builtin_unordered_cmp (loc, fndecl,
10523                                          arg0, arg1, UNGE_EXPR, GE_EXPR);
10524     case BUILT_IN_ISLESSEQUAL:
10525       return fold_builtin_unordered_cmp (loc, fndecl,
10526                                          arg0, arg1, UNGT_EXPR, GT_EXPR);
10527     case BUILT_IN_ISLESSGREATER:
10528       return fold_builtin_unordered_cmp (loc, fndecl,
10529                                          arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10530     case BUILT_IN_ISUNORDERED:
10531       return fold_builtin_unordered_cmp (loc, fndecl,
10532                                          arg0, arg1, UNORDERED_EXPR,
10533                                          NOP_EXPR);
10534
10535       /* We do the folding for va_start in the expander.  */
10536     case BUILT_IN_VA_START:
10537       break;
10538
10539     case BUILT_IN_SPRINTF:
10540       return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10541
10542     case BUILT_IN_OBJECT_SIZE:
10543       return fold_builtin_object_size (arg0, arg1);
10544
10545     case BUILT_IN_PRINTF:
10546     case BUILT_IN_PRINTF_UNLOCKED:
10547     case BUILT_IN_VPRINTF:
10548       return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10549
10550     case BUILT_IN_PRINTF_CHK:
10551     case BUILT_IN_VPRINTF_CHK:
10552       if (!validate_arg (arg0, INTEGER_TYPE)
10553           || TREE_SIDE_EFFECTS (arg0))
10554         return NULL_TREE;
10555       else
10556         return fold_builtin_printf (loc, fndecl,
10557                                     arg1, NULL_TREE, ignore, fcode);
10558     break;
10559
10560     case BUILT_IN_FPRINTF:
10561     case BUILT_IN_FPRINTF_UNLOCKED:
10562     case BUILT_IN_VFPRINTF:
10563       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10564                                    ignore, fcode);
10565
10566     default:
10567       break;
10568     }
10569   return NULL_TREE;
10570 }
10571
10572 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10573    and ARG2.  IGNORE is true if the result of the function call is ignored.
10574    This function returns NULL_TREE if no simplification was possible.  */
10575
10576 static tree
10577 fold_builtin_3 (location_t loc, tree fndecl,
10578                 tree arg0, tree arg1, tree arg2, bool ignore)
10579 {
10580   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10581   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10582   switch (fcode)
10583     {
10584
10585     CASE_FLT_FN (BUILT_IN_SINCOS):
10586       return fold_builtin_sincos (loc, arg0, arg1, arg2);
10587
10588     CASE_FLT_FN (BUILT_IN_FMA):
10589       if (validate_arg (arg0, REAL_TYPE)
10590           && validate_arg(arg1, REAL_TYPE)
10591           && validate_arg(arg2, REAL_TYPE))
10592         return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
10593     break;
10594
10595     CASE_FLT_FN (BUILT_IN_REMQUO):
10596       if (validate_arg (arg0, REAL_TYPE)
10597           && validate_arg(arg1, REAL_TYPE)
10598           && validate_arg(arg2, POINTER_TYPE))
10599         return do_mpfr_remquo (arg0, arg1, arg2);
10600     break;
10601
10602     case BUILT_IN_MEMSET:
10603       return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10604
10605     case BUILT_IN_BCOPY:
10606       return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10607                                      void_type_node, true, /*endp=*/3);
10608
10609     case BUILT_IN_MEMCPY:
10610       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10611                                      type, ignore, /*endp=*/0);
10612
10613     case BUILT_IN_MEMPCPY:
10614       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10615                                      type, ignore, /*endp=*/1);
10616
10617     case BUILT_IN_MEMMOVE:
10618       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10619                                      type, ignore, /*endp=*/3);
10620
10621     case BUILT_IN_STRNCAT:
10622       return fold_builtin_strncat (loc, arg0, arg1, arg2);
10623
10624     case BUILT_IN_STRNCPY:
10625       return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10626
10627     case BUILT_IN_STRNCMP:
10628       return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10629
10630     case BUILT_IN_MEMCHR:
10631       return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10632
10633     case BUILT_IN_BCMP:
10634     case BUILT_IN_MEMCMP:
10635       return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10636
10637     case BUILT_IN_SPRINTF:
10638       return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10639
10640     case BUILT_IN_STRCPY_CHK:
10641     case BUILT_IN_STPCPY_CHK:
10642       return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10643                                       ignore, fcode);
10644
10645     case BUILT_IN_STRCAT_CHK:
10646       return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10647
10648     case BUILT_IN_PRINTF_CHK:
10649     case BUILT_IN_VPRINTF_CHK:
10650       if (!validate_arg (arg0, INTEGER_TYPE)
10651           || TREE_SIDE_EFFECTS (arg0))
10652         return NULL_TREE;
10653       else
10654         return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10655     break;
10656
10657     case BUILT_IN_FPRINTF:
10658     case BUILT_IN_FPRINTF_UNLOCKED:
10659     case BUILT_IN_VFPRINTF:
10660       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10661                                    ignore, fcode);
10662
10663     case BUILT_IN_FPRINTF_CHK:
10664     case BUILT_IN_VFPRINTF_CHK:
10665       if (!validate_arg (arg1, INTEGER_TYPE)
10666           || TREE_SIDE_EFFECTS (arg1))
10667         return NULL_TREE;
10668       else
10669         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10670                                      ignore, fcode);
10671
10672     default:
10673       break;
10674     }
10675   return NULL_TREE;
10676 }
10677
10678 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10679    ARG2, and ARG3.  IGNORE is true if the result of the function call is
10680    ignored.  This function returns NULL_TREE if no simplification was
10681    possible.  */
10682
10683 static tree
10684 fold_builtin_4 (location_t loc, tree fndecl,
10685                 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10686 {
10687   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10688
10689   switch (fcode)
10690     {
10691     case BUILT_IN_MEMCPY_CHK:
10692     case BUILT_IN_MEMPCPY_CHK:
10693     case BUILT_IN_MEMMOVE_CHK:
10694     case BUILT_IN_MEMSET_CHK:
10695       return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10696                                       NULL_TREE, ignore,
10697                                       DECL_FUNCTION_CODE (fndecl));
10698
10699     case BUILT_IN_STRNCPY_CHK:
10700       return fold_builtin_strncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE);
10701
10702     case BUILT_IN_STRNCAT_CHK:
10703       return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
10704
10705     case BUILT_IN_FPRINTF_CHK:
10706     case BUILT_IN_VFPRINTF_CHK:
10707       if (!validate_arg (arg1, INTEGER_TYPE)
10708           || TREE_SIDE_EFFECTS (arg1))
10709         return NULL_TREE;
10710       else
10711         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
10712                                      ignore, fcode);
10713     break;
10714
10715     default:
10716       break;
10717     }
10718   return NULL_TREE;
10719 }
10720
10721 /* Fold a call to built-in function FNDECL.  ARGS is an array of NARGS
10722     arguments, where NARGS <= 4.  IGNORE is true if the result of the
10723     function call is ignored.  This function returns NULL_TREE if no
10724     simplification was possible.  Note that this only folds builtins with
10725     fixed argument patterns.  Foldings that do varargs-to-varargs
10726     transformations, or that match calls with more than 4 arguments,
10727     need to be handled with fold_builtin_varargs instead.  */
10728
10729 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10730
10731 static tree
10732 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
10733 {
10734   tree ret = NULL_TREE;
10735
10736   switch (nargs)
10737     {
10738     case 0:
10739       ret = fold_builtin_0 (loc, fndecl, ignore);
10740       break;
10741     case 1:
10742       ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
10743       break;
10744     case 2:
10745       ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
10746       break;
10747     case 3:
10748       ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
10749       break;
10750     case 4:
10751       ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
10752                             ignore);
10753       break;
10754     default:
10755       break;
10756     }
10757   if (ret)
10758     {
10759       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10760       SET_EXPR_LOCATION (ret, loc);
10761       TREE_NO_WARNING (ret) = 1;
10762       return ret;
10763     }
10764   return NULL_TREE;
10765 }
10766
10767 /* Builtins with folding operations that operate on "..." arguments
10768    need special handling; we need to store the arguments in a convenient
10769    data structure before attempting any folding.  Fortunately there are
10770    only a few builtins that fall into this category.  FNDECL is the
10771    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10772    result of the function call is ignored.  */
10773
10774 static tree
10775 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
10776                       bool ignore ATTRIBUTE_UNUSED)
10777 {
10778   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10779   tree ret = NULL_TREE;
10780
10781   switch (fcode)
10782     {
10783     case BUILT_IN_SPRINTF_CHK:
10784     case BUILT_IN_VSPRINTF_CHK:
10785       ret = fold_builtin_sprintf_chk (loc, exp, fcode);
10786       break;
10787
10788     case BUILT_IN_SNPRINTF_CHK:
10789     case BUILT_IN_VSNPRINTF_CHK:
10790       ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
10791       break;
10792
10793     case BUILT_IN_FPCLASSIFY:
10794       ret = fold_builtin_fpclassify (loc, exp);
10795       break;
10796
10797     default:
10798       break;
10799     }
10800   if (ret)
10801     {
10802       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10803       SET_EXPR_LOCATION (ret, loc);
10804       TREE_NO_WARNING (ret) = 1;
10805       return ret;
10806     }
10807   return NULL_TREE;
10808 }
10809
10810 /* Return true if FNDECL shouldn't be folded right now.
10811    If a built-in function has an inline attribute always_inline
10812    wrapper, defer folding it after always_inline functions have
10813    been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10814    might not be performed.  */
10815
10816 static bool
10817 avoid_folding_inline_builtin (tree fndecl)
10818 {
10819   return (DECL_DECLARED_INLINE_P (fndecl)
10820           && DECL_DISREGARD_INLINE_LIMITS (fndecl)
10821           && cfun
10822           && !cfun->always_inline_functions_inlined
10823           && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
10824 }
10825
10826 /* A wrapper function for builtin folding that prevents warnings for
10827    "statement without effect" and the like, caused by removing the
10828    call node earlier than the warning is generated.  */
10829
10830 tree
10831 fold_call_expr (location_t loc, tree exp, bool ignore)
10832 {
10833   tree ret = NULL_TREE;
10834   tree fndecl = get_callee_fndecl (exp);
10835   if (fndecl
10836       && TREE_CODE (fndecl) == FUNCTION_DECL
10837       && DECL_BUILT_IN (fndecl)
10838       /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10839          yet.  Defer folding until we see all the arguments
10840          (after inlining).  */
10841       && !CALL_EXPR_VA_ARG_PACK (exp))
10842     {
10843       int nargs = call_expr_nargs (exp);
10844
10845       /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10846          instead last argument is __builtin_va_arg_pack ().  Defer folding
10847          even in that case, until arguments are finalized.  */
10848       if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
10849         {
10850           tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
10851           if (fndecl2
10852               && TREE_CODE (fndecl2) == FUNCTION_DECL
10853               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10854               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10855             return NULL_TREE;
10856         }
10857
10858       if (avoid_folding_inline_builtin (fndecl))
10859         return NULL_TREE;
10860
10861       /* FIXME: Don't use a list in this interface.  */
10862       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10863           return targetm.fold_builtin (fndecl, CALL_EXPR_ARGS (exp), ignore);
10864       else
10865         {
10866           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
10867             {
10868               tree *args = CALL_EXPR_ARGP (exp);
10869               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
10870             }
10871           if (!ret)
10872             ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
10873           if (ret)
10874             return ret;
10875         }
10876     }
10877   return NULL_TREE;
10878 }
10879
10880 /* Conveniently construct a function call expression.  FNDECL names the
10881     function to be called and ARGLIST is a TREE_LIST of arguments.  */
10882
10883 tree
10884 build_function_call_expr (location_t loc, tree fndecl, tree arglist)
10885 {
10886   tree fntype = TREE_TYPE (fndecl);
10887   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10888   int n = list_length (arglist);
10889   tree *argarray = (tree *) alloca (n * sizeof (tree));
10890   int i;
10891
10892   for (i = 0; i < n; i++, arglist = TREE_CHAIN (arglist))
10893     argarray[i] = TREE_VALUE (arglist);
10894   return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10895 }
10896
10897 /* Conveniently construct a function call expression.  FNDECL names the
10898    function to be called, N is the number of arguments, and the "..."
10899    parameters are the argument expressions.  */
10900
10901 tree
10902 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10903 {
10904   va_list ap;
10905   tree fntype = TREE_TYPE (fndecl);
10906   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10907   tree *argarray = (tree *) alloca (n * sizeof (tree));
10908   int i;
10909
10910   va_start (ap, n);
10911   for (i = 0; i < n; i++)
10912     argarray[i] = va_arg (ap, tree);
10913   va_end (ap);
10914   return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10915 }
10916
10917 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10918    N arguments are passed in the array ARGARRAY.  */
10919
10920 tree
10921 fold_builtin_call_array (location_t loc, tree type,
10922                          tree fn,
10923                          int n,
10924                          tree *argarray)
10925 {
10926   tree ret = NULL_TREE;
10927   int i;
10928    tree exp;
10929
10930   if (TREE_CODE (fn) == ADDR_EXPR)
10931   {
10932     tree fndecl = TREE_OPERAND (fn, 0);
10933     if (TREE_CODE (fndecl) == FUNCTION_DECL
10934         && DECL_BUILT_IN (fndecl))
10935       {
10936         /* If last argument is __builtin_va_arg_pack (), arguments to this
10937            function are not finalized yet.  Defer folding until they are.  */
10938         if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
10939           {
10940             tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
10941             if (fndecl2
10942                 && TREE_CODE (fndecl2) == FUNCTION_DECL
10943                 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10944                 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10945               return build_call_array_loc (loc, type, fn, n, argarray);
10946           }
10947         if (avoid_folding_inline_builtin (fndecl))
10948           return build_call_array_loc (loc, type, fn, n, argarray);
10949         if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10950           {
10951             tree arglist = NULL_TREE;
10952             for (i = n - 1; i >= 0; i--)
10953               arglist = tree_cons (NULL_TREE, argarray[i], arglist);
10954             ret = targetm.fold_builtin (fndecl, arglist, false);
10955             if (ret)
10956               return ret;
10957             return build_call_array_loc (loc, type, fn, n, argarray);
10958           }
10959         else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
10960           {
10961             /* First try the transformations that don't require consing up
10962                an exp.  */
10963             ret = fold_builtin_n (loc, fndecl, argarray, n, false);
10964             if (ret)
10965               return ret;
10966           }
10967
10968         /* If we got this far, we need to build an exp.  */
10969         exp = build_call_array_loc (loc, type, fn, n, argarray);
10970         ret = fold_builtin_varargs (loc, fndecl, exp, false);
10971         return ret ? ret : exp;
10972       }
10973   }
10974
10975   return build_call_array_loc (loc, type, fn, n, argarray);
10976 }
10977
10978 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10979    along with N new arguments specified as the "..." parameters.  SKIP
10980    is the number of arguments in EXP to be omitted.  This function is used
10981    to do varargs-to-varargs transformations.  */
10982
10983 static tree
10984 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
10985 {
10986   int oldnargs = call_expr_nargs (exp);
10987   int nargs = oldnargs - skip + n;
10988   tree fntype = TREE_TYPE (fndecl);
10989   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10990   tree *buffer;
10991
10992   if (n > 0)
10993     {
10994       int i, j;
10995       va_list ap;
10996
10997       buffer = XALLOCAVEC (tree, nargs);
10998       va_start (ap, n);
10999       for (i = 0; i < n; i++)
11000         buffer[i] = va_arg (ap, tree);
11001       va_end (ap);
11002       for (j = skip; j < oldnargs; j++, i++)
11003         buffer[i] = CALL_EXPR_ARG (exp, j);
11004     }
11005   else
11006     buffer = CALL_EXPR_ARGP (exp) + skip;
11007
11008   return fold (build_call_array_loc (loc, TREE_TYPE (exp), fn, nargs, buffer));
11009 }
11010
11011 /* Validate a single argument ARG against a tree code CODE representing
11012    a type.  */
11013
11014 static bool
11015 validate_arg (const_tree arg, enum tree_code code)
11016 {
11017   if (!arg)
11018     return false;
11019   else if (code == POINTER_TYPE)
11020     return POINTER_TYPE_P (TREE_TYPE (arg));
11021   else if (code == INTEGER_TYPE)
11022     return INTEGRAL_TYPE_P (TREE_TYPE (arg));
11023   return code == TREE_CODE (TREE_TYPE (arg));
11024 }
11025
11026 /* This function validates the types of a function call argument list
11027    against a specified list of tree_codes.  If the last specifier is a 0,
11028    that represents an ellipses, otherwise the last specifier must be a
11029    VOID_TYPE.
11030
11031    This is the GIMPLE version of validate_arglist.  Eventually we want to
11032    completely convert builtins.c to work from GIMPLEs and the tree based
11033    validate_arglist will then be removed.  */
11034
11035 bool
11036 validate_gimple_arglist (const_gimple call, ...)
11037 {
11038   enum tree_code code;
11039   bool res = 0;
11040   va_list ap;
11041   const_tree arg;
11042   size_t i;
11043
11044   va_start (ap, call);
11045   i = 0;
11046
11047   do
11048     {
11049       code = (enum tree_code) va_arg (ap, int);
11050       switch (code)
11051         {
11052         case 0:
11053           /* This signifies an ellipses, any further arguments are all ok.  */
11054           res = true;
11055           goto end;
11056         case VOID_TYPE:
11057           /* This signifies an endlink, if no arguments remain, return
11058              true, otherwise return false.  */
11059           res = (i == gimple_call_num_args (call));
11060           goto end;
11061         default:
11062           /* If no parameters remain or the parameter's code does not
11063              match the specified code, return false.  Otherwise continue
11064              checking any remaining arguments.  */
11065           arg = gimple_call_arg (call, i++);
11066           if (!validate_arg (arg, code))
11067             goto end;
11068           break;
11069         }
11070     }
11071   while (1);
11072
11073   /* We need gotos here since we can only have one VA_CLOSE in a
11074      function.  */
11075  end: ;
11076   va_end (ap);
11077
11078   return res;
11079 }
11080
11081 /* This function validates the types of a function call argument list
11082    against a specified list of tree_codes.  If the last specifier is a 0,
11083    that represents an ellipses, otherwise the last specifier must be a
11084    VOID_TYPE.  */
11085
11086 bool
11087 validate_arglist (const_tree callexpr, ...)
11088 {
11089   enum tree_code code;
11090   bool res = 0;
11091   va_list ap;
11092   const_call_expr_arg_iterator iter;
11093   const_tree arg;
11094
11095   va_start (ap, callexpr);
11096   init_const_call_expr_arg_iterator (callexpr, &iter);
11097
11098   do
11099     {
11100       code = (enum tree_code) va_arg (ap, int);
11101       switch (code)
11102         {
11103         case 0:
11104           /* This signifies an ellipses, any further arguments are all ok.  */
11105           res = true;
11106           goto end;
11107         case VOID_TYPE:
11108           /* This signifies an endlink, if no arguments remain, return
11109              true, otherwise return false.  */
11110           res = !more_const_call_expr_args_p (&iter);
11111           goto end;
11112         default:
11113           /* If no parameters remain or the parameter's code does not
11114              match the specified code, return false.  Otherwise continue
11115              checking any remaining arguments.  */
11116           arg = next_const_call_expr_arg (&iter);
11117           if (!validate_arg (arg, code))
11118             goto end;
11119           break;
11120         }
11121     }
11122   while (1);
11123
11124   /* We need gotos here since we can only have one VA_CLOSE in a
11125      function.  */
11126  end: ;
11127   va_end (ap);
11128
11129   return res;
11130 }
11131
11132 /* Default target-specific builtin expander that does nothing.  */
11133
11134 rtx
11135 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11136                         rtx target ATTRIBUTE_UNUSED,
11137                         rtx subtarget ATTRIBUTE_UNUSED,
11138                         enum machine_mode mode ATTRIBUTE_UNUSED,
11139                         int ignore ATTRIBUTE_UNUSED)
11140 {
11141   return NULL_RTX;
11142 }
11143
11144 /* Returns true is EXP represents data that would potentially reside
11145    in a readonly section.  */
11146
11147 static bool
11148 readonly_data_expr (tree exp)
11149 {
11150   STRIP_NOPS (exp);
11151
11152   if (TREE_CODE (exp) != ADDR_EXPR)
11153     return false;
11154
11155   exp = get_base_address (TREE_OPERAND (exp, 0));
11156   if (!exp)
11157     return false;
11158
11159   /* Make sure we call decl_readonly_section only for trees it
11160      can handle (since it returns true for everything it doesn't
11161      understand).  */
11162   if (TREE_CODE (exp) == STRING_CST
11163       || TREE_CODE (exp) == CONSTRUCTOR
11164       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11165     return decl_readonly_section (exp, 0);
11166   else
11167     return false;
11168 }
11169
11170 /* Simplify a call to the strstr builtin.  S1 and S2 are the arguments
11171    to the call, and TYPE is its return type.
11172
11173    Return NULL_TREE if no simplification was possible, otherwise return the
11174    simplified form of the call as a tree.
11175
11176    The simplified form may be a constant or other expression which
11177    computes the same value, but in a more efficient manner (including
11178    calls to other builtin functions).
11179
11180    The call may contain arguments which need to be evaluated, but
11181    which are not useful to determine the result of the call.  In
11182    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11183    COMPOUND_EXPR will be an argument which must be evaluated.
11184    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11185    COMPOUND_EXPR in the chain will contain the tree for the simplified
11186    form of the builtin function call.  */
11187
11188 static tree
11189 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11190 {
11191   if (!validate_arg (s1, POINTER_TYPE)
11192       || !validate_arg (s2, POINTER_TYPE))
11193     return NULL_TREE;
11194   else
11195     {
11196       tree fn;
11197       const char *p1, *p2;
11198
11199       p2 = c_getstr (s2);
11200       if (p2 == NULL)
11201         return NULL_TREE;
11202
11203       p1 = c_getstr (s1);
11204       if (p1 != NULL)
11205         {
11206           const char *r = strstr (p1, p2);
11207           tree tem;
11208
11209           if (r == NULL)
11210             return build_int_cst (TREE_TYPE (s1), 0);
11211
11212           /* Return an offset into the constant string argument.  */
11213           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11214                              s1, size_int (r - p1));
11215           return fold_convert_loc (loc, type, tem);
11216         }
11217
11218       /* The argument is const char *, and the result is char *, so we need
11219          a type conversion here to avoid a warning.  */
11220       if (p2[0] == '\0')
11221         return fold_convert_loc (loc, type, s1);
11222
11223       if (p2[1] != '\0')
11224         return NULL_TREE;
11225
11226       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11227       if (!fn)
11228         return NULL_TREE;
11229
11230       /* New argument list transforming strstr(s1, s2) to
11231          strchr(s1, s2[0]).  */
11232       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11233     }
11234 }
11235
11236 /* Simplify a call to the strchr builtin.  S1 and S2 are the arguments to
11237    the call, and TYPE is its return type.
11238
11239    Return NULL_TREE if no simplification was possible, otherwise return the
11240    simplified form of the call as a tree.
11241
11242    The simplified form may be a constant or other expression which
11243    computes the same value, but in a more efficient manner (including
11244    calls to other builtin functions).
11245
11246    The call may contain arguments which need to be evaluated, but
11247    which are not useful to determine the result of the call.  In
11248    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11249    COMPOUND_EXPR will be an argument which must be evaluated.
11250    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11251    COMPOUND_EXPR in the chain will contain the tree for the simplified
11252    form of the builtin function call.  */
11253
11254 static tree
11255 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11256 {
11257   if (!validate_arg (s1, POINTER_TYPE)
11258       || !validate_arg (s2, INTEGER_TYPE))
11259     return NULL_TREE;
11260   else
11261     {
11262       const char *p1;
11263
11264       if (TREE_CODE (s2) != INTEGER_CST)
11265         return NULL_TREE;
11266
11267       p1 = c_getstr (s1);
11268       if (p1 != NULL)
11269         {
11270           char c;
11271           const char *r;
11272           tree tem;
11273
11274           if (target_char_cast (s2, &c))
11275             return NULL_TREE;
11276
11277           r = strchr (p1, c);
11278
11279           if (r == NULL)
11280             return build_int_cst (TREE_TYPE (s1), 0);
11281
11282           /* Return an offset into the constant string argument.  */
11283           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11284                              s1, size_int (r - p1));
11285           return fold_convert_loc (loc, type, tem);
11286         }
11287       return NULL_TREE;
11288     }
11289 }
11290
11291 /* Simplify a call to the strrchr builtin.  S1 and S2 are the arguments to
11292    the call, and TYPE is its return type.
11293
11294    Return NULL_TREE if no simplification was possible, otherwise return the
11295    simplified form of the call as a tree.
11296
11297    The simplified form may be a constant or other expression which
11298    computes the same value, but in a more efficient manner (including
11299    calls to other builtin functions).
11300
11301    The call may contain arguments which need to be evaluated, but
11302    which are not useful to determine the result of the call.  In
11303    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11304    COMPOUND_EXPR will be an argument which must be evaluated.
11305    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11306    COMPOUND_EXPR in the chain will contain the tree for the simplified
11307    form of the builtin function call.  */
11308
11309 static tree
11310 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11311 {
11312   if (!validate_arg (s1, POINTER_TYPE)
11313       || !validate_arg (s2, INTEGER_TYPE))
11314     return NULL_TREE;
11315   else
11316     {
11317       tree fn;
11318       const char *p1;
11319
11320       if (TREE_CODE (s2) != INTEGER_CST)
11321         return NULL_TREE;
11322
11323       p1 = c_getstr (s1);
11324       if (p1 != NULL)
11325         {
11326           char c;
11327           const char *r;
11328           tree tem;
11329
11330           if (target_char_cast (s2, &c))
11331             return NULL_TREE;
11332
11333           r = strrchr (p1, c);
11334
11335           if (r == NULL)
11336             return build_int_cst (TREE_TYPE (s1), 0);
11337
11338           /* Return an offset into the constant string argument.  */
11339           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11340                              s1, size_int (r - p1));
11341           return fold_convert_loc (loc, type, tem);
11342         }
11343
11344       if (! integer_zerop (s2))
11345         return NULL_TREE;
11346
11347       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11348       if (!fn)
11349         return NULL_TREE;
11350
11351       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
11352       return build_call_expr_loc (loc, fn, 2, s1, s2);
11353     }
11354 }
11355
11356 /* Simplify a call to the strpbrk builtin.  S1 and S2 are the arguments
11357    to the call, and TYPE is its return type.
11358
11359    Return NULL_TREE if no simplification was possible, otherwise return the
11360    simplified form of the call as a tree.
11361
11362    The simplified form may be a constant or other expression which
11363    computes the same value, but in a more efficient manner (including
11364    calls to other builtin functions).
11365
11366    The call may contain arguments which need to be evaluated, but
11367    which are not useful to determine the result of the call.  In
11368    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11369    COMPOUND_EXPR will be an argument which must be evaluated.
11370    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11371    COMPOUND_EXPR in the chain will contain the tree for the simplified
11372    form of the builtin function call.  */
11373
11374 static tree
11375 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11376 {
11377   if (!validate_arg (s1, POINTER_TYPE)
11378       || !validate_arg (s2, POINTER_TYPE))
11379     return NULL_TREE;
11380   else
11381     {
11382       tree fn;
11383       const char *p1, *p2;
11384
11385       p2 = c_getstr (s2);
11386       if (p2 == NULL)
11387         return NULL_TREE;
11388
11389       p1 = c_getstr (s1);
11390       if (p1 != NULL)
11391         {
11392           const char *r = strpbrk (p1, p2);
11393           tree tem;
11394
11395           if (r == NULL)
11396             return build_int_cst (TREE_TYPE (s1), 0);
11397
11398           /* Return an offset into the constant string argument.  */
11399           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11400                              s1, size_int (r - p1));
11401           return fold_convert_loc (loc, type, tem);
11402         }
11403
11404       if (p2[0] == '\0')
11405         /* strpbrk(x, "") == NULL.
11406            Evaluate and ignore s1 in case it had side-effects.  */
11407         return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11408
11409       if (p2[1] != '\0')
11410         return NULL_TREE;  /* Really call strpbrk.  */
11411
11412       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11413       if (!fn)
11414         return NULL_TREE;
11415
11416       /* New argument list transforming strpbrk(s1, s2) to
11417          strchr(s1, s2[0]).  */
11418       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11419     }
11420 }
11421
11422 /* Simplify a call to the strcat builtin.  DST and SRC are the arguments
11423    to the call.
11424
11425    Return NULL_TREE if no simplification was possible, otherwise return the
11426    simplified form of the call as a tree.
11427
11428    The simplified form may be a constant or other expression which
11429    computes the same value, but in a more efficient manner (including
11430    calls to other builtin functions).
11431
11432    The call may contain arguments which need to be evaluated, but
11433    which are not useful to determine the result of the call.  In
11434    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11435    COMPOUND_EXPR will be an argument which must be evaluated.
11436    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11437    COMPOUND_EXPR in the chain will contain the tree for the simplified
11438    form of the builtin function call.  */
11439
11440 static tree
11441 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11442 {
11443   if (!validate_arg (dst, POINTER_TYPE)
11444       || !validate_arg (src, POINTER_TYPE))
11445     return NULL_TREE;
11446   else
11447     {
11448       const char *p = c_getstr (src);
11449
11450       /* If the string length is zero, return the dst parameter.  */
11451       if (p && *p == '\0')
11452         return dst;
11453
11454       if (optimize_insn_for_speed_p ())
11455         {
11456           /* See if we can store by pieces into (dst + strlen(dst)).  */
11457           tree newdst, call;
11458           tree strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11459           tree strcpy_fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11460
11461           if (!strlen_fn || !strcpy_fn)
11462             return NULL_TREE;
11463
11464           /* If we don't have a movstr we don't want to emit an strcpy
11465              call.  We have to do that if the length of the source string
11466              isn't computable (in that case we can use memcpy probably
11467              later expanding to a sequence of mov instructions).  If we
11468              have movstr instructions we can emit strcpy calls.  */
11469           if (!HAVE_movstr)
11470             {
11471               tree len = c_strlen (src, 1);
11472               if (! len || TREE_SIDE_EFFECTS (len))
11473                 return NULL_TREE;
11474             }
11475
11476           /* Stabilize the argument list.  */
11477           dst = builtin_save_expr (dst);
11478
11479           /* Create strlen (dst).  */
11480           newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11481           /* Create (dst p+ strlen (dst)).  */
11482
11483           newdst = fold_build2_loc (loc, POINTER_PLUS_EXPR,
11484                                 TREE_TYPE (dst), dst, newdst);
11485           newdst = builtin_save_expr (newdst);
11486
11487           call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11488           return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11489         }
11490       return NULL_TREE;
11491     }
11492 }
11493
11494 /* Simplify a call to the strncat builtin.  DST, SRC, and LEN are the
11495    arguments to the call.
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_strncat (location_t loc, tree dst, tree src, tree len)
11514 {
11515   if (!validate_arg (dst, POINTER_TYPE)
11516       || !validate_arg (src, POINTER_TYPE)
11517       || !validate_arg (len, INTEGER_TYPE))
11518     return NULL_TREE;
11519   else
11520     {
11521       const char *p = c_getstr (src);
11522
11523       /* If the requested length is zero, or the src parameter string
11524          length is zero, return the dst parameter.  */
11525       if (integer_zerop (len) || (p && *p == '\0'))
11526         return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11527
11528       /* If the requested len is greater than or equal to the string
11529          length, call strcat.  */
11530       if (TREE_CODE (len) == INTEGER_CST && p
11531           && compare_tree_int (len, strlen (p)) >= 0)
11532         {
11533           tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
11534
11535           /* If the replacement _DECL isn't initialized, don't do the
11536              transformation.  */
11537           if (!fn)
11538             return NULL_TREE;
11539
11540           return build_call_expr_loc (loc, fn, 2, dst, src);
11541         }
11542       return NULL_TREE;
11543     }
11544 }
11545
11546 /* Simplify a call to the strspn builtin.  S1 and S2 are the arguments
11547    to the call.
11548
11549    Return NULL_TREE if no simplification was possible, otherwise return the
11550    simplified form of the call as a tree.
11551
11552    The simplified form may be a constant or other expression which
11553    computes the same value, but in a more efficient manner (including
11554    calls to other builtin functions).
11555
11556    The call may contain arguments which need to be evaluated, but
11557    which are not useful to determine the result of the call.  In
11558    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11559    COMPOUND_EXPR will be an argument which must be evaluated.
11560    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11561    COMPOUND_EXPR in the chain will contain the tree for the simplified
11562    form of the builtin function call.  */
11563
11564 static tree
11565 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11566 {
11567   if (!validate_arg (s1, POINTER_TYPE)
11568       || !validate_arg (s2, POINTER_TYPE))
11569     return NULL_TREE;
11570   else
11571     {
11572       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11573
11574       /* If both arguments are constants, evaluate at compile-time.  */
11575       if (p1 && p2)
11576         {
11577           const size_t r = strspn (p1, p2);
11578           return size_int (r);
11579         }
11580
11581       /* If either argument is "", return NULL_TREE.  */
11582       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11583         /* Evaluate and ignore both arguments in case either one has
11584            side-effects.  */
11585         return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11586                                   s1, s2);
11587       return NULL_TREE;
11588     }
11589 }
11590
11591 /* Simplify a call to the strcspn builtin.  S1 and S2 are the arguments
11592    to the call.
11593
11594    Return NULL_TREE if no simplification was possible, otherwise return the
11595    simplified form of the call as a tree.
11596
11597    The simplified form may be a constant or other expression which
11598    computes the same value, but in a more efficient manner (including
11599    calls to other builtin functions).
11600
11601    The call may contain arguments which need to be evaluated, but
11602    which are not useful to determine the result of the call.  In
11603    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11604    COMPOUND_EXPR will be an argument which must be evaluated.
11605    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11606    COMPOUND_EXPR in the chain will contain the tree for the simplified
11607    form of the builtin function call.  */
11608
11609 static tree
11610 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11611 {
11612   if (!validate_arg (s1, POINTER_TYPE)
11613       || !validate_arg (s2, POINTER_TYPE))
11614     return NULL_TREE;
11615   else
11616     {
11617       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11618
11619       /* If both arguments are constants, evaluate at compile-time.  */
11620       if (p1 && p2)
11621         {
11622           const size_t r = strcspn (p1, p2);
11623           return size_int (r);
11624         }
11625
11626       /* If the first argument is "", return NULL_TREE.  */
11627       if (p1 && *p1 == '\0')
11628         {
11629           /* Evaluate and ignore argument s2 in case it has
11630              side-effects.  */
11631           return omit_one_operand_loc (loc, size_type_node,
11632                                    size_zero_node, s2);
11633         }
11634
11635       /* If the second argument is "", return __builtin_strlen(s1).  */
11636       if (p2 && *p2 == '\0')
11637         {
11638           tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11639
11640           /* If the replacement _DECL isn't initialized, don't do the
11641              transformation.  */
11642           if (!fn)
11643             return NULL_TREE;
11644
11645           return build_call_expr_loc (loc, fn, 1, s1);
11646         }
11647       return NULL_TREE;
11648     }
11649 }
11650
11651 /* Fold a call to the fputs builtin.  ARG0 and ARG1 are the arguments
11652    to the call.  IGNORE is true if the value returned
11653    by the builtin will be ignored.  UNLOCKED is true is true if this
11654    actually a call to fputs_unlocked.  If LEN in non-NULL, it represents
11655    the known length of the string.  Return NULL_TREE if no simplification
11656    was possible.  */
11657
11658 tree
11659 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
11660                     bool ignore, bool unlocked, tree len)
11661 {
11662   /* If we're using an unlocked function, assume the other unlocked
11663      functions exist explicitly.  */
11664   tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
11665     : implicit_built_in_decls[BUILT_IN_FPUTC];
11666   tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
11667     : implicit_built_in_decls[BUILT_IN_FWRITE];
11668
11669   /* If the return value is used, don't do the transformation.  */
11670   if (!ignore)
11671     return NULL_TREE;
11672
11673   /* Verify the arguments in the original call.  */
11674   if (!validate_arg (arg0, POINTER_TYPE)
11675       || !validate_arg (arg1, POINTER_TYPE))
11676     return NULL_TREE;
11677
11678   if (! len)
11679     len = c_strlen (arg0, 0);
11680
11681   /* Get the length of the string passed to fputs.  If the length
11682      can't be determined, punt.  */
11683   if (!len
11684       || TREE_CODE (len) != INTEGER_CST)
11685     return NULL_TREE;
11686
11687   switch (compare_tree_int (len, 1))
11688     {
11689     case -1: /* length is 0, delete the call entirely .  */
11690       return omit_one_operand_loc (loc, integer_type_node,
11691                                integer_zero_node, arg1);;
11692
11693     case 0: /* length is 1, call fputc.  */
11694       {
11695         const char *p = c_getstr (arg0);
11696
11697         if (p != NULL)
11698           {
11699             if (fn_fputc)
11700               return build_call_expr_loc (loc, fn_fputc, 2,
11701                                       build_int_cst (NULL_TREE, p[0]), arg1);
11702             else
11703               return NULL_TREE;
11704           }
11705       }
11706       /* FALLTHROUGH */
11707     case 1: /* length is greater than 1, call fwrite.  */
11708       {
11709         /* If optimizing for size keep fputs.  */
11710         if (optimize_function_for_size_p (cfun))
11711           return NULL_TREE;
11712         /* New argument list transforming fputs(string, stream) to
11713            fwrite(string, 1, len, stream).  */
11714         if (fn_fwrite)
11715           return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
11716                                   size_one_node, len, arg1);
11717         else
11718           return NULL_TREE;
11719       }
11720     default:
11721       gcc_unreachable ();
11722     }
11723   return NULL_TREE;
11724 }
11725
11726 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11727    produced.  False otherwise.  This is done so that we don't output the error
11728    or warning twice or three times.  */
11729
11730 bool
11731 fold_builtin_next_arg (tree exp, bool va_start_p)
11732 {
11733   tree fntype = TREE_TYPE (current_function_decl);
11734   int nargs = call_expr_nargs (exp);
11735   tree arg;
11736
11737   if (TYPE_ARG_TYPES (fntype) == 0
11738       || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
11739           == void_type_node))
11740     {
11741       error ("%<va_start%> used in function with fixed args");
11742       return true;
11743     }
11744
11745   if (va_start_p)
11746     {
11747       if (va_start_p && (nargs != 2))
11748         {
11749           error ("wrong number of arguments to function %<va_start%>");
11750           return true;
11751         }
11752       arg = CALL_EXPR_ARG (exp, 1);
11753     }
11754   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11755      when we checked the arguments and if needed issued a warning.  */
11756   else
11757     {
11758       if (nargs == 0)
11759         {
11760           /* Evidently an out of date version of <stdarg.h>; can't validate
11761              va_start's second argument, but can still work as intended.  */
11762           warning (0, "%<__builtin_next_arg%> called without an argument");
11763           return true;
11764         }
11765       else if (nargs > 1)
11766         {
11767           error ("wrong number of arguments to function %<__builtin_next_arg%>");
11768           return true;
11769         }
11770       arg = CALL_EXPR_ARG (exp, 0);
11771     }
11772
11773   if (TREE_CODE (arg) == SSA_NAME)
11774     arg = SSA_NAME_VAR (arg);
11775
11776   /* We destructively modify the call to be __builtin_va_start (ap, 0)
11777      or __builtin_next_arg (0) the first time we see it, after checking
11778      the arguments and if needed issuing a warning.  */
11779   if (!integer_zerop (arg))
11780     {
11781       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
11782
11783       /* Strip off all nops for the sake of the comparison.  This
11784          is not quite the same as STRIP_NOPS.  It does more.
11785          We must also strip off INDIRECT_EXPR for C++ reference
11786          parameters.  */
11787       while (CONVERT_EXPR_P (arg)
11788              || TREE_CODE (arg) == INDIRECT_REF)
11789         arg = TREE_OPERAND (arg, 0);
11790       if (arg != last_parm)
11791         {
11792           /* FIXME: Sometimes with the tree optimizers we can get the
11793              not the last argument even though the user used the last
11794              argument.  We just warn and set the arg to be the last
11795              argument so that we will get wrong-code because of
11796              it.  */
11797           warning (0, "second parameter of %<va_start%> not last named argument");
11798         }
11799
11800       /* Undefined by C99 7.15.1.4p4 (va_start):
11801          "If the parameter parmN is declared with the register storage
11802          class, with a function or array type, or with a type that is
11803          not compatible with the type that results after application of
11804          the default argument promotions, the behavior is undefined."
11805       */
11806       else if (DECL_REGISTER (arg))
11807         warning (0, "undefined behaviour when second parameter of "
11808                  "%<va_start%> is declared with %<register%> storage");
11809
11810       /* We want to verify the second parameter just once before the tree
11811          optimizers are run and then avoid keeping it in the tree,
11812          as otherwise we could warn even for correct code like:
11813          void foo (int i, ...)
11814          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
11815       if (va_start_p)
11816         CALL_EXPR_ARG (exp, 1) = integer_zero_node;
11817       else
11818         CALL_EXPR_ARG (exp, 0) = integer_zero_node;
11819     }
11820   return false;
11821 }
11822
11823
11824 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11825    ORIG may be null if this is a 2-argument call.  We don't attempt to
11826    simplify calls with more than 3 arguments.
11827
11828    Return NULL_TREE if no simplification was possible, otherwise return the
11829    simplified form of the call as a tree.  If IGNORED is true, it means that
11830    the caller does not use the returned value of the function.  */
11831
11832 static tree
11833 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
11834                       tree orig, int ignored)
11835 {
11836   tree call, retval;
11837   const char *fmt_str = NULL;
11838
11839   /* Verify the required arguments in the original call.  We deal with two
11840      types of sprintf() calls: 'sprintf (str, fmt)' and
11841      'sprintf (dest, "%s", orig)'.  */
11842   if (!validate_arg (dest, POINTER_TYPE)
11843       || !validate_arg (fmt, POINTER_TYPE))
11844     return NULL_TREE;
11845   if (orig && !validate_arg (orig, POINTER_TYPE))
11846     return NULL_TREE;
11847
11848   /* Check whether the format is a literal string constant.  */
11849   fmt_str = c_getstr (fmt);
11850   if (fmt_str == NULL)
11851     return NULL_TREE;
11852
11853   call = NULL_TREE;
11854   retval = NULL_TREE;
11855
11856   if (!init_target_chars ())
11857     return NULL_TREE;
11858
11859   /* If the format doesn't contain % args or %%, use strcpy.  */
11860   if (strchr (fmt_str, target_percent) == NULL)
11861     {
11862       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11863
11864       if (!fn)
11865         return NULL_TREE;
11866
11867       /* Don't optimize sprintf (buf, "abc", ptr++).  */
11868       if (orig)
11869         return NULL_TREE;
11870
11871       /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11872          'format' is known to contain no % formats.  */
11873       call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11874       if (!ignored)
11875         retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11876     }
11877
11878   /* If the format is "%s", use strcpy if the result isn't used.  */
11879   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11880     {
11881       tree fn;
11882       fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11883
11884       if (!fn)
11885         return NULL_TREE;
11886
11887       /* Don't crash on sprintf (str1, "%s").  */
11888       if (!orig)
11889         return NULL_TREE;
11890
11891       /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2).  */
11892       if (!ignored)
11893         {
11894           retval = c_strlen (orig, 1);
11895           if (!retval || TREE_CODE (retval) != INTEGER_CST)
11896             return NULL_TREE;
11897         }
11898       call = build_call_expr_loc (loc, fn, 2, dest, orig);
11899     }
11900
11901   if (call && retval)
11902     {
11903       retval = fold_convert_loc
11904         (loc, TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
11905          retval);
11906       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11907     }
11908   else
11909     return call;
11910 }
11911
11912 /* Expand a call EXP to __builtin_object_size.  */
11913
11914 rtx
11915 expand_builtin_object_size (tree exp)
11916 {
11917   tree ost;
11918   int object_size_type;
11919   tree fndecl = get_callee_fndecl (exp);
11920
11921   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
11922     {
11923       error ("%Kfirst argument of %D must be a pointer, second integer constant",
11924              exp, fndecl);
11925       expand_builtin_trap ();
11926       return const0_rtx;
11927     }
11928
11929   ost = CALL_EXPR_ARG (exp, 1);
11930   STRIP_NOPS (ost);
11931
11932   if (TREE_CODE (ost) != INTEGER_CST
11933       || tree_int_cst_sgn (ost) < 0
11934       || compare_tree_int (ost, 3) > 0)
11935     {
11936       error ("%Klast argument of %D is not integer constant between 0 and 3",
11937              exp, fndecl);
11938       expand_builtin_trap ();
11939       return const0_rtx;
11940     }
11941
11942   object_size_type = tree_low_cst (ost, 0);
11943
11944   return object_size_type < 2 ? constm1_rtx : const0_rtx;
11945 }
11946
11947 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11948    FCODE is the BUILT_IN_* to use.
11949    Return NULL_RTX if we failed; the caller should emit a normal call,
11950    otherwise try to get the result in TARGET, if convenient (and in
11951    mode MODE if that's convenient).  */
11952
11953 static rtx
11954 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
11955                            enum built_in_function fcode)
11956 {
11957   tree dest, src, len, size;
11958
11959   if (!validate_arglist (exp,
11960                          POINTER_TYPE,
11961                          fcode == BUILT_IN_MEMSET_CHK
11962                          ? INTEGER_TYPE : POINTER_TYPE,
11963                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
11964     return NULL_RTX;
11965
11966   dest = CALL_EXPR_ARG (exp, 0);
11967   src = CALL_EXPR_ARG (exp, 1);
11968   len = CALL_EXPR_ARG (exp, 2);
11969   size = CALL_EXPR_ARG (exp, 3);
11970
11971   if (! host_integerp (size, 1))
11972     return NULL_RTX;
11973
11974   if (host_integerp (len, 1) || integer_all_onesp (size))
11975     {
11976       tree fn;
11977
11978       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
11979         {
11980           warning_at (tree_nonartificial_location (exp),
11981                       0, "%Kcall to %D will always overflow destination buffer",
11982                       exp, get_callee_fndecl (exp));
11983           return NULL_RTX;
11984         }
11985
11986       fn = NULL_TREE;
11987       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11988          mem{cpy,pcpy,move,set} is available.  */
11989       switch (fcode)
11990         {
11991         case BUILT_IN_MEMCPY_CHK:
11992           fn = built_in_decls[BUILT_IN_MEMCPY];
11993           break;
11994         case BUILT_IN_MEMPCPY_CHK:
11995           fn = built_in_decls[BUILT_IN_MEMPCPY];
11996           break;
11997         case BUILT_IN_MEMMOVE_CHK:
11998           fn = built_in_decls[BUILT_IN_MEMMOVE];
11999           break;
12000         case BUILT_IN_MEMSET_CHK:
12001           fn = built_in_decls[BUILT_IN_MEMSET];
12002           break;
12003         default:
12004           break;
12005         }
12006
12007       if (! fn)
12008         return NULL_RTX;
12009
12010       fn = build_call_nofold (fn, 3, dest, src, len);
12011       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12012       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12013       return expand_expr (fn, target, mode, EXPAND_NORMAL);
12014     }
12015   else if (fcode == BUILT_IN_MEMSET_CHK)
12016     return NULL_RTX;
12017   else
12018     {
12019       unsigned int dest_align
12020         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
12021
12022       /* If DEST is not a pointer type, call the normal function.  */
12023       if (dest_align == 0)
12024         return NULL_RTX;
12025
12026       /* If SRC and DEST are the same (and not volatile), do nothing.  */
12027       if (operand_equal_p (src, dest, 0))
12028         {
12029           tree expr;
12030
12031           if (fcode != BUILT_IN_MEMPCPY_CHK)
12032             {
12033               /* Evaluate and ignore LEN in case it has side-effects.  */
12034               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
12035               return expand_expr (dest, target, mode, EXPAND_NORMAL);
12036             }
12037
12038           expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
12039           return expand_expr (expr, target, mode, EXPAND_NORMAL);
12040         }
12041
12042       /* __memmove_chk special case.  */
12043       if (fcode == BUILT_IN_MEMMOVE_CHK)
12044         {
12045           unsigned int src_align
12046             = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
12047
12048           if (src_align == 0)
12049             return NULL_RTX;
12050
12051           /* If src is categorized for a readonly section we can use
12052              normal __memcpy_chk.  */
12053           if (readonly_data_expr (src))
12054             {
12055               tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12056               if (!fn)
12057                 return NULL_RTX;
12058               fn = build_call_nofold (fn, 4, dest, src, len, size);
12059               gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12060               CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12061               return expand_expr (fn, target, mode, EXPAND_NORMAL);
12062             }
12063         }
12064       return NULL_RTX;
12065     }
12066 }
12067
12068 /* Emit warning if a buffer overflow is detected at compile time.  */
12069
12070 static void
12071 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
12072 {
12073   int is_strlen = 0;
12074   tree len, size;
12075   location_t loc = tree_nonartificial_location (exp);
12076
12077   switch (fcode)
12078     {
12079     case BUILT_IN_STRCPY_CHK:
12080     case BUILT_IN_STPCPY_CHK:
12081     /* For __strcat_chk the warning will be emitted only if overflowing
12082        by at least strlen (dest) + 1 bytes.  */
12083     case BUILT_IN_STRCAT_CHK:
12084       len = CALL_EXPR_ARG (exp, 1);
12085       size = CALL_EXPR_ARG (exp, 2);
12086       is_strlen = 1;
12087       break;
12088     case BUILT_IN_STRNCAT_CHK:
12089     case BUILT_IN_STRNCPY_CHK:
12090       len = CALL_EXPR_ARG (exp, 2);
12091       size = CALL_EXPR_ARG (exp, 3);
12092       break;
12093     case BUILT_IN_SNPRINTF_CHK:
12094     case BUILT_IN_VSNPRINTF_CHK:
12095       len = CALL_EXPR_ARG (exp, 1);
12096       size = CALL_EXPR_ARG (exp, 3);
12097       break;
12098     default:
12099       gcc_unreachable ();
12100     }
12101
12102   if (!len || !size)
12103     return;
12104
12105   if (! host_integerp (size, 1) || integer_all_onesp (size))
12106     return;
12107
12108   if (is_strlen)
12109     {
12110       len = c_strlen (len, 1);
12111       if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12112         return;
12113     }
12114   else if (fcode == BUILT_IN_STRNCAT_CHK)
12115     {
12116       tree src = CALL_EXPR_ARG (exp, 1);
12117       if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12118         return;
12119       src = c_strlen (src, 1);
12120       if (! src || ! host_integerp (src, 1))
12121         {
12122           warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12123                       exp, get_callee_fndecl (exp));
12124           return;
12125         }
12126       else if (tree_int_cst_lt (src, size))
12127         return;
12128     }
12129   else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12130     return;
12131
12132   warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12133               exp, get_callee_fndecl (exp));
12134 }
12135
12136 /* Emit warning if a buffer overflow is detected at compile time
12137    in __sprintf_chk/__vsprintf_chk calls.  */
12138
12139 static void
12140 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12141 {
12142   tree dest, size, len, fmt, flag;
12143   const char *fmt_str;
12144   int nargs = call_expr_nargs (exp);
12145
12146   /* Verify the required arguments in the original call.  */
12147
12148   if (nargs < 4)
12149     return;
12150   dest = CALL_EXPR_ARG (exp, 0);
12151   flag = CALL_EXPR_ARG (exp, 1);
12152   size = CALL_EXPR_ARG (exp, 2);
12153   fmt = CALL_EXPR_ARG (exp, 3);
12154
12155   if (! host_integerp (size, 1) || integer_all_onesp (size))
12156     return;
12157
12158   /* Check whether the format is a literal string constant.  */
12159   fmt_str = c_getstr (fmt);
12160   if (fmt_str == NULL)
12161     return;
12162
12163   if (!init_target_chars ())
12164     return;
12165
12166   /* If the format doesn't contain % args or %%, we know its size.  */
12167   if (strchr (fmt_str, target_percent) == 0)
12168     len = build_int_cstu (size_type_node, strlen (fmt_str));
12169   /* If the format is "%s" and first ... argument is a string literal,
12170      we know it too.  */
12171   else if (fcode == BUILT_IN_SPRINTF_CHK
12172            && strcmp (fmt_str, target_percent_s) == 0)
12173     {
12174       tree arg;
12175
12176       if (nargs < 5)
12177         return;
12178       arg = CALL_EXPR_ARG (exp, 4);
12179       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12180         return;
12181
12182       len = c_strlen (arg, 1);
12183       if (!len || ! host_integerp (len, 1))
12184         return;
12185     }
12186   else
12187     return;
12188
12189   if (! tree_int_cst_lt (len, size))
12190     warning_at (tree_nonartificial_location (exp),
12191                 0, "%Kcall to %D will always overflow destination buffer",
12192                 exp, get_callee_fndecl (exp));
12193 }
12194
12195 /* Emit warning if a free is called with address of a variable.  */
12196
12197 static void
12198 maybe_emit_free_warning (tree exp)
12199 {
12200   tree arg = CALL_EXPR_ARG (exp, 0);
12201
12202   STRIP_NOPS (arg);
12203   if (TREE_CODE (arg) != ADDR_EXPR)
12204     return;
12205
12206   arg = get_base_address (TREE_OPERAND (arg, 0));
12207   if (arg == NULL || INDIRECT_REF_P (arg))
12208     return;
12209
12210   if (SSA_VAR_P (arg))
12211     warning_at (tree_nonartificial_location (exp),
12212                 0, "%Kattempt to free a non-heap object %qD", exp, arg);
12213   else
12214     warning_at (tree_nonartificial_location (exp),
12215                 0, "%Kattempt to free a non-heap object", exp);
12216 }
12217
12218 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12219    if possible.  */
12220
12221 tree
12222 fold_builtin_object_size (tree ptr, tree ost)
12223 {
12224   tree ret = NULL_TREE;
12225   int object_size_type;
12226
12227   if (!validate_arg (ptr, POINTER_TYPE)
12228       || !validate_arg (ost, INTEGER_TYPE))
12229     return NULL_TREE;
12230
12231   STRIP_NOPS (ost);
12232
12233   if (TREE_CODE (ost) != INTEGER_CST
12234       || tree_int_cst_sgn (ost) < 0
12235       || compare_tree_int (ost, 3) > 0)
12236     return NULL_TREE;
12237
12238   object_size_type = tree_low_cst (ost, 0);
12239
12240   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12241      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12242      and (size_t) 0 for types 2 and 3.  */
12243   if (TREE_SIDE_EFFECTS (ptr))
12244     return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12245
12246   if (TREE_CODE (ptr) == ADDR_EXPR)
12247     ret = build_int_cstu (size_type_node,
12248                           compute_builtin_object_size (ptr, object_size_type));
12249
12250   else if (TREE_CODE (ptr) == SSA_NAME)
12251     {
12252       unsigned HOST_WIDE_INT bytes;
12253
12254       /* If object size is not known yet, delay folding until
12255        later.  Maybe subsequent passes will help determining
12256        it.  */
12257       bytes = compute_builtin_object_size (ptr, object_size_type);
12258       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2
12259                                              ? -1 : 0))
12260         ret = build_int_cstu (size_type_node, bytes);
12261     }
12262
12263   if (ret)
12264     {
12265       unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (ret);
12266       HOST_WIDE_INT high = TREE_INT_CST_HIGH (ret);
12267       if (fit_double_type (low, high, &low, &high, TREE_TYPE (ret)))
12268         ret = NULL_TREE;
12269     }
12270
12271   return ret;
12272 }
12273
12274 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12275    DEST, SRC, LEN, and SIZE are the arguments to the call.
12276    IGNORE is true, if return value can be ignored.  FCODE is the BUILT_IN_*
12277    code of the builtin.  If MAXLEN is not NULL, it is maximum length
12278    passed as third argument.  */
12279
12280 tree
12281 fold_builtin_memory_chk (location_t loc, tree fndecl,
12282                          tree dest, tree src, tree len, tree size,
12283                          tree maxlen, bool ignore,
12284                          enum built_in_function fcode)
12285 {
12286   tree fn;
12287
12288   if (!validate_arg (dest, POINTER_TYPE)
12289       || !validate_arg (src,
12290                         (fcode == BUILT_IN_MEMSET_CHK
12291                          ? INTEGER_TYPE : POINTER_TYPE))
12292       || !validate_arg (len, INTEGER_TYPE)
12293       || !validate_arg (size, INTEGER_TYPE))
12294     return NULL_TREE;
12295
12296   /* If SRC and DEST are the same (and not volatile), return DEST
12297      (resp. DEST+LEN for __mempcpy_chk).  */
12298   if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12299     {
12300       if (fcode != BUILT_IN_MEMPCPY_CHK)
12301         return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12302                                  dest, len);
12303       else
12304         {
12305           tree temp = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest),
12306                                    dest, len);
12307           return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12308         }
12309     }
12310
12311   if (! host_integerp (size, 1))
12312     return NULL_TREE;
12313
12314   if (! integer_all_onesp (size))
12315     {
12316       if (! host_integerp (len, 1))
12317         {
12318           /* If LEN is not constant, try MAXLEN too.
12319              For MAXLEN only allow optimizing into non-_ocs function
12320              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12321           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12322             {
12323               if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12324                 {
12325                   /* (void) __mempcpy_chk () can be optimized into
12326                      (void) __memcpy_chk ().  */
12327                   fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12328                   if (!fn)
12329                     return NULL_TREE;
12330
12331                   return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12332                 }
12333               return NULL_TREE;
12334             }
12335         }
12336       else
12337         maxlen = len;
12338
12339       if (tree_int_cst_lt (size, maxlen))
12340         return NULL_TREE;
12341     }
12342
12343   fn = NULL_TREE;
12344   /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12345      mem{cpy,pcpy,move,set} is available.  */
12346   switch (fcode)
12347     {
12348     case BUILT_IN_MEMCPY_CHK:
12349       fn = built_in_decls[BUILT_IN_MEMCPY];
12350       break;
12351     case BUILT_IN_MEMPCPY_CHK:
12352       fn = built_in_decls[BUILT_IN_MEMPCPY];
12353       break;
12354     case BUILT_IN_MEMMOVE_CHK:
12355       fn = built_in_decls[BUILT_IN_MEMMOVE];
12356       break;
12357     case BUILT_IN_MEMSET_CHK:
12358       fn = built_in_decls[BUILT_IN_MEMSET];
12359       break;
12360     default:
12361       break;
12362     }
12363
12364   if (!fn)
12365     return NULL_TREE;
12366
12367   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12368 }
12369
12370 /* Fold a call to the __st[rp]cpy_chk builtin.
12371    DEST, SRC, and SIZE are the arguments to the call.
12372    IGNORE is true if return value can be ignored.  FCODE is the BUILT_IN_*
12373    code of the builtin.  If MAXLEN is not NULL, it is maximum length of
12374    strings passed as second argument.  */
12375
12376 tree
12377 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12378                          tree src, tree size,
12379                          tree maxlen, bool ignore,
12380                          enum built_in_function fcode)
12381 {
12382   tree len, fn;
12383
12384   if (!validate_arg (dest, POINTER_TYPE)
12385       || !validate_arg (src, POINTER_TYPE)
12386       || !validate_arg (size, INTEGER_TYPE))
12387     return NULL_TREE;
12388
12389   /* If SRC and DEST are the same (and not volatile), return DEST.  */
12390   if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12391     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12392
12393   if (! host_integerp (size, 1))
12394     return NULL_TREE;
12395
12396   if (! integer_all_onesp (size))
12397     {
12398       len = c_strlen (src, 1);
12399       if (! len || ! host_integerp (len, 1))
12400         {
12401           /* If LEN is not constant, try MAXLEN too.
12402              For MAXLEN only allow optimizing into non-_ocs function
12403              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12404           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12405             {
12406               if (fcode == BUILT_IN_STPCPY_CHK)
12407                 {
12408                   if (! ignore)
12409                     return NULL_TREE;
12410
12411                   /* If return value of __stpcpy_chk is ignored,
12412                      optimize into __strcpy_chk.  */
12413                   fn = built_in_decls[BUILT_IN_STRCPY_CHK];
12414                   if (!fn)
12415                     return NULL_TREE;
12416
12417                   return build_call_expr_loc (loc, fn, 3, dest, src, size);
12418                 }
12419
12420               if (! len || TREE_SIDE_EFFECTS (len))
12421                 return NULL_TREE;
12422
12423               /* If c_strlen returned something, but not a constant,
12424                  transform __strcpy_chk into __memcpy_chk.  */
12425               fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12426               if (!fn)
12427                 return NULL_TREE;
12428
12429               len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
12430               return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12431                                        build_call_expr_loc (loc, fn, 4,
12432                                                         dest, src, len, size));
12433             }
12434         }
12435       else
12436         maxlen = len;
12437
12438       if (! tree_int_cst_lt (maxlen, size))
12439         return NULL_TREE;
12440     }
12441
12442   /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available.  */
12443   fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
12444                       ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
12445   if (!fn)
12446     return NULL_TREE;
12447
12448   return build_call_expr_loc (loc, fn, 2, dest, src);
12449 }
12450
12451 /* Fold a call to the __strncpy_chk builtin.  DEST, SRC, LEN, and SIZE
12452    are the arguments to the call.  If MAXLEN is not NULL, it is maximum
12453    length passed as third argument.  */
12454
12455 tree
12456 fold_builtin_strncpy_chk (location_t loc, tree dest, tree src,
12457                           tree len, tree size, tree maxlen)
12458 {
12459   tree fn;
12460
12461   if (!validate_arg (dest, POINTER_TYPE)
12462       || !validate_arg (src, POINTER_TYPE)
12463       || !validate_arg (len, INTEGER_TYPE)
12464       || !validate_arg (size, INTEGER_TYPE))
12465     return NULL_TREE;
12466
12467   if (! host_integerp (size, 1))
12468     return NULL_TREE;
12469
12470   if (! integer_all_onesp (size))
12471     {
12472       if (! host_integerp (len, 1))
12473         {
12474           /* If LEN is not constant, try MAXLEN too.
12475              For MAXLEN only allow optimizing into non-_ocs function
12476              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12477           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12478             return NULL_TREE;
12479         }
12480       else
12481         maxlen = len;
12482
12483       if (tree_int_cst_lt (size, maxlen))
12484         return NULL_TREE;
12485     }
12486
12487   /* If __builtin_strncpy_chk is used, assume strncpy is available.  */
12488   fn = built_in_decls[BUILT_IN_STRNCPY];
12489   if (!fn)
12490     return NULL_TREE;
12491
12492   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12493 }
12494
12495 /* Fold a call to the __strcat_chk builtin FNDECL.  DEST, SRC, and SIZE
12496    are the arguments to the call.  */
12497
12498 static tree
12499 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12500                          tree src, tree size)
12501 {
12502   tree fn;
12503   const char *p;
12504
12505   if (!validate_arg (dest, POINTER_TYPE)
12506       || !validate_arg (src, POINTER_TYPE)
12507       || !validate_arg (size, INTEGER_TYPE))
12508     return NULL_TREE;
12509
12510   p = c_getstr (src);
12511   /* If the SRC parameter is "", return DEST.  */
12512   if (p && *p == '\0')
12513     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12514
12515   if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12516     return NULL_TREE;
12517
12518   /* If __builtin_strcat_chk is used, assume strcat is available.  */
12519   fn = built_in_decls[BUILT_IN_STRCAT];
12520   if (!fn)
12521     return NULL_TREE;
12522
12523   return build_call_expr_loc (loc, fn, 2, dest, src);
12524 }
12525
12526 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12527    LEN, and SIZE.  */
12528
12529 static tree
12530 fold_builtin_strncat_chk (location_t loc, tree fndecl,
12531                           tree dest, tree src, tree len, tree size)
12532 {
12533   tree fn;
12534   const char *p;
12535
12536   if (!validate_arg (dest, POINTER_TYPE)
12537       || !validate_arg (src, POINTER_TYPE)
12538       || !validate_arg (size, INTEGER_TYPE)
12539       || !validate_arg (size, INTEGER_TYPE))
12540     return NULL_TREE;
12541
12542   p = c_getstr (src);
12543   /* If the SRC parameter is "" or if LEN is 0, return DEST.  */
12544   if (p && *p == '\0')
12545     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12546   else if (integer_zerop (len))
12547     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12548
12549   if (! host_integerp (size, 1))
12550     return NULL_TREE;
12551
12552   if (! integer_all_onesp (size))
12553     {
12554       tree src_len = c_strlen (src, 1);
12555       if (src_len
12556           && host_integerp (src_len, 1)
12557           && host_integerp (len, 1)
12558           && ! tree_int_cst_lt (len, src_len))
12559         {
12560           /* If LEN >= strlen (SRC), optimize into __strcat_chk.  */
12561           fn = built_in_decls[BUILT_IN_STRCAT_CHK];
12562           if (!fn)
12563             return NULL_TREE;
12564
12565           return build_call_expr_loc (loc, fn, 3, dest, src, size);
12566         }
12567       return NULL_TREE;
12568     }
12569
12570   /* If __builtin_strncat_chk is used, assume strncat is available.  */
12571   fn = built_in_decls[BUILT_IN_STRNCAT];
12572   if (!fn)
12573     return NULL_TREE;
12574
12575   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12576 }
12577
12578 /* Fold a call EXP to __{,v}sprintf_chk.  Return NULL_TREE if
12579    a normal call should be emitted rather than expanding the function
12580    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
12581
12582 static tree
12583 fold_builtin_sprintf_chk (location_t loc, tree exp,
12584                           enum built_in_function fcode)
12585 {
12586   tree dest, size, len, fn, fmt, flag;
12587   const char *fmt_str;
12588   int nargs = call_expr_nargs (exp);
12589
12590   /* Verify the required arguments in the original call.  */
12591   if (nargs < 4)
12592     return NULL_TREE;
12593   dest = CALL_EXPR_ARG (exp, 0);
12594   if (!validate_arg (dest, POINTER_TYPE))
12595     return NULL_TREE;
12596   flag = CALL_EXPR_ARG (exp, 1);
12597   if (!validate_arg (flag, INTEGER_TYPE))
12598     return NULL_TREE;
12599   size = CALL_EXPR_ARG (exp, 2);
12600   if (!validate_arg (size, INTEGER_TYPE))
12601     return NULL_TREE;
12602   fmt = CALL_EXPR_ARG (exp, 3);
12603   if (!validate_arg (fmt, POINTER_TYPE))
12604     return NULL_TREE;
12605
12606   if (! host_integerp (size, 1))
12607     return NULL_TREE;
12608
12609   len = NULL_TREE;
12610
12611   if (!init_target_chars ())
12612     return NULL_TREE;
12613
12614   /* Check whether the format is a literal string constant.  */
12615   fmt_str = c_getstr (fmt);
12616   if (fmt_str != NULL)
12617     {
12618       /* If the format doesn't contain % args or %%, we know the size.  */
12619       if (strchr (fmt_str, target_percent) == 0)
12620         {
12621           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
12622             len = build_int_cstu (size_type_node, strlen (fmt_str));
12623         }
12624       /* If the format is "%s" and first ... argument is a string literal,
12625          we know the size too.  */
12626       else if (fcode == BUILT_IN_SPRINTF_CHK
12627                && strcmp (fmt_str, target_percent_s) == 0)
12628         {
12629           tree arg;
12630
12631           if (nargs == 5)
12632             {
12633               arg = CALL_EXPR_ARG (exp, 4);
12634               if (validate_arg (arg, POINTER_TYPE))
12635                 {
12636                   len = c_strlen (arg, 1);
12637                   if (! len || ! host_integerp (len, 1))
12638                     len = NULL_TREE;
12639                 }
12640             }
12641         }
12642     }
12643
12644   if (! integer_all_onesp (size))
12645     {
12646       if (! len || ! tree_int_cst_lt (len, size))
12647         return NULL_TREE;
12648     }
12649
12650   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12651      or if format doesn't contain % chars or is "%s".  */
12652   if (! integer_zerop (flag))
12653     {
12654       if (fmt_str == NULL)
12655         return NULL_TREE;
12656       if (strchr (fmt_str, target_percent) != NULL
12657           && strcmp (fmt_str, target_percent_s))
12658         return NULL_TREE;
12659     }
12660
12661   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
12662   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
12663                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
12664   if (!fn)
12665     return NULL_TREE;
12666
12667   return rewrite_call_expr (loc, exp, 4, fn, 2, dest, fmt);
12668 }
12669
12670 /* Fold a call EXP to {,v}snprintf.  Return NULL_TREE if
12671    a normal call should be emitted rather than expanding the function
12672    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
12673    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
12674    passed as second argument.  */
12675
12676 tree
12677 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
12678                            enum built_in_function fcode)
12679 {
12680   tree dest, size, len, fn, fmt, flag;
12681   const char *fmt_str;
12682
12683   /* Verify the required arguments in the original call.  */
12684   if (call_expr_nargs (exp) < 5)
12685     return NULL_TREE;
12686   dest = CALL_EXPR_ARG (exp, 0);
12687   if (!validate_arg (dest, POINTER_TYPE))
12688     return NULL_TREE;
12689   len = CALL_EXPR_ARG (exp, 1);
12690   if (!validate_arg (len, INTEGER_TYPE))
12691     return NULL_TREE;
12692   flag = CALL_EXPR_ARG (exp, 2);
12693   if (!validate_arg (flag, INTEGER_TYPE))
12694     return NULL_TREE;
12695   size = CALL_EXPR_ARG (exp, 3);
12696   if (!validate_arg (size, INTEGER_TYPE))
12697     return NULL_TREE;
12698   fmt = CALL_EXPR_ARG (exp, 4);
12699   if (!validate_arg (fmt, POINTER_TYPE))
12700     return NULL_TREE;
12701
12702   if (! host_integerp (size, 1))
12703     return NULL_TREE;
12704
12705   if (! integer_all_onesp (size))
12706     {
12707       if (! host_integerp (len, 1))
12708         {
12709           /* If LEN is not constant, try MAXLEN too.
12710              For MAXLEN only allow optimizing into non-_ocs function
12711              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12712           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12713             return NULL_TREE;
12714         }
12715       else
12716         maxlen = len;
12717
12718       if (tree_int_cst_lt (size, maxlen))
12719         return NULL_TREE;
12720     }
12721
12722   if (!init_target_chars ())
12723     return NULL_TREE;
12724
12725   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12726      or if format doesn't contain % chars or is "%s".  */
12727   if (! integer_zerop (flag))
12728     {
12729       fmt_str = c_getstr (fmt);
12730       if (fmt_str == NULL)
12731         return NULL_TREE;
12732       if (strchr (fmt_str, target_percent) != NULL
12733           && strcmp (fmt_str, target_percent_s))
12734         return NULL_TREE;
12735     }
12736
12737   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12738      available.  */
12739   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
12740                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
12741   if (!fn)
12742     return NULL_TREE;
12743
12744   return rewrite_call_expr (loc, exp, 5, fn, 3, dest, len, fmt);
12745 }
12746
12747 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12748    FMT and ARG are the arguments to the call; we don't fold cases with
12749    more than 2 arguments, and ARG may be null if this is a 1-argument case.
12750
12751    Return NULL_TREE if no simplification was possible, otherwise return the
12752    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12753    code of the function to be simplified.  */
12754
12755 static tree
12756 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
12757                      tree arg, bool ignore,
12758                      enum built_in_function fcode)
12759 {
12760   tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
12761   const char *fmt_str = NULL;
12762
12763   /* If the return value is used, don't do the transformation.  */
12764   if (! ignore)
12765     return NULL_TREE;
12766
12767   /* Verify the required arguments in the original call.  */
12768   if (!validate_arg (fmt, POINTER_TYPE))
12769     return NULL_TREE;
12770
12771   /* Check whether the format is a literal string constant.  */
12772   fmt_str = c_getstr (fmt);
12773   if (fmt_str == NULL)
12774     return NULL_TREE;
12775
12776   if (fcode == BUILT_IN_PRINTF_UNLOCKED)
12777     {
12778       /* If we're using an unlocked function, assume the other
12779          unlocked functions exist explicitly.  */
12780       fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
12781       fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
12782     }
12783   else
12784     {
12785       fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
12786       fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
12787     }
12788
12789   if (!init_target_chars ())
12790     return NULL_TREE;
12791
12792   if (strcmp (fmt_str, target_percent_s) == 0
12793       || strchr (fmt_str, target_percent) == NULL)
12794     {
12795       const char *str;
12796
12797       if (strcmp (fmt_str, target_percent_s) == 0)
12798         {
12799           if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12800             return NULL_TREE;
12801
12802           if (!arg || !validate_arg (arg, POINTER_TYPE))
12803             return NULL_TREE;
12804
12805           str = c_getstr (arg);
12806           if (str == NULL)
12807             return NULL_TREE;
12808         }
12809       else
12810         {
12811           /* The format specifier doesn't contain any '%' characters.  */
12812           if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
12813               && arg)
12814             return NULL_TREE;
12815           str = fmt_str;
12816         }
12817
12818       /* If the string was "", printf does nothing.  */
12819       if (str[0] == '\0')
12820         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12821
12822       /* If the string has length of 1, call putchar.  */
12823       if (str[1] == '\0')
12824         {
12825           /* Given printf("c"), (where c is any one character,)
12826              convert "c"[0] to an int and pass that to the replacement
12827              function.  */
12828           newarg = build_int_cst (NULL_TREE, str[0]);
12829           if (fn_putchar)
12830             call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
12831         }
12832       else
12833         {
12834           /* If the string was "string\n", call puts("string").  */
12835           size_t len = strlen (str);
12836           if ((unsigned char)str[len - 1] == target_newline)
12837             {
12838               /* Create a NUL-terminated string that's one char shorter
12839                  than the original, stripping off the trailing '\n'.  */
12840               char *newstr = XALLOCAVEC (char, len);
12841               memcpy (newstr, str, len - 1);
12842               newstr[len - 1] = 0;
12843
12844               newarg = build_string_literal (len, newstr);
12845               if (fn_puts)
12846                 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
12847             }
12848           else
12849             /* We'd like to arrange to call fputs(string,stdout) here,
12850                but we need stdout and don't have a way to get it yet.  */
12851             return NULL_TREE;
12852         }
12853     }
12854
12855   /* The other optimizations can be done only on the non-va_list variants.  */
12856   else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12857     return NULL_TREE;
12858
12859   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
12860   else if (strcmp (fmt_str, target_percent_s_newline) == 0)
12861     {
12862       if (!arg || !validate_arg (arg, POINTER_TYPE))
12863         return NULL_TREE;
12864       if (fn_puts)
12865         call = build_call_expr_loc (loc, fn_puts, 1, arg);
12866     }
12867
12868   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
12869   else if (strcmp (fmt_str, target_percent_c) == 0)
12870     {
12871       if (!arg || !validate_arg (arg, INTEGER_TYPE))
12872         return NULL_TREE;
12873       if (fn_putchar)
12874         call = build_call_expr_loc (loc, fn_putchar, 1, arg);
12875     }
12876
12877   if (!call)
12878     return NULL_TREE;
12879
12880   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12881 }
12882
12883 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
12884    FP, FMT, and ARG are the arguments to the call.  We don't fold calls with
12885    more than 3 arguments, and ARG may be null in the 2-argument case.
12886
12887    Return NULL_TREE if no simplification was possible, otherwise return the
12888    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12889    code of the function to be simplified.  */
12890
12891 static tree
12892 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
12893                       tree fmt, tree arg, bool ignore,
12894                       enum built_in_function fcode)
12895 {
12896   tree fn_fputc, fn_fputs, call = NULL_TREE;
12897   const char *fmt_str = NULL;
12898
12899   /* If the return value is used, don't do the transformation.  */
12900   if (! ignore)
12901     return NULL_TREE;
12902
12903   /* Verify the required arguments in the original call.  */
12904   if (!validate_arg (fp, POINTER_TYPE))
12905     return NULL_TREE;
12906   if (!validate_arg (fmt, POINTER_TYPE))
12907     return NULL_TREE;
12908
12909   /* Check whether the format is a literal string constant.  */
12910   fmt_str = c_getstr (fmt);
12911   if (fmt_str == NULL)
12912     return NULL_TREE;
12913
12914   if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
12915     {
12916       /* If we're using an unlocked function, assume the other
12917          unlocked functions exist explicitly.  */
12918       fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
12919       fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
12920     }
12921   else
12922     {
12923       fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
12924       fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
12925     }
12926
12927   if (!init_target_chars ())
12928     return NULL_TREE;
12929
12930   /* If the format doesn't contain % args or %%, use strcpy.  */
12931   if (strchr (fmt_str, target_percent) == NULL)
12932     {
12933       if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
12934           && arg)
12935         return NULL_TREE;
12936
12937       /* If the format specifier was "", fprintf does nothing.  */
12938       if (fmt_str[0] == '\0')
12939         {
12940           /* If FP has side-effects, just wait until gimplification is
12941              done.  */
12942           if (TREE_SIDE_EFFECTS (fp))
12943             return NULL_TREE;
12944
12945           return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12946         }
12947
12948       /* When "string" doesn't contain %, replace all cases of
12949          fprintf (fp, string) with fputs (string, fp).  The fputs
12950          builtin will take care of special cases like length == 1.  */
12951       if (fn_fputs)
12952         call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
12953     }
12954
12955   /* The other optimizations can be done only on the non-va_list variants.  */
12956   else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
12957     return NULL_TREE;
12958
12959   /* If the format specifier was "%s", call __builtin_fputs (arg, fp).  */
12960   else if (strcmp (fmt_str, target_percent_s) == 0)
12961     {
12962       if (!arg || !validate_arg (arg, POINTER_TYPE))
12963         return NULL_TREE;
12964       if (fn_fputs)
12965         call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
12966     }
12967
12968   /* If the format specifier was "%c", call __builtin_fputc (arg, fp).  */
12969   else if (strcmp (fmt_str, target_percent_c) == 0)
12970     {
12971       if (!arg || !validate_arg (arg, INTEGER_TYPE))
12972         return NULL_TREE;
12973       if (fn_fputc)
12974         call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
12975     }
12976
12977   if (!call)
12978     return NULL_TREE;
12979   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12980 }
12981
12982 /* Initialize format string characters in the target charset.  */
12983
12984 static bool
12985 init_target_chars (void)
12986 {
12987   static bool init;
12988   if (!init)
12989     {
12990       target_newline = lang_hooks.to_target_charset ('\n');
12991       target_percent = lang_hooks.to_target_charset ('%');
12992       target_c = lang_hooks.to_target_charset ('c');
12993       target_s = lang_hooks.to_target_charset ('s');
12994       if (target_newline == 0 || target_percent == 0 || target_c == 0
12995           || target_s == 0)
12996         return false;
12997
12998       target_percent_c[0] = target_percent;
12999       target_percent_c[1] = target_c;
13000       target_percent_c[2] = '\0';
13001
13002       target_percent_s[0] = target_percent;
13003       target_percent_s[1] = target_s;
13004       target_percent_s[2] = '\0';
13005
13006       target_percent_s_newline[0] = target_percent;
13007       target_percent_s_newline[1] = target_s;
13008       target_percent_s_newline[2] = target_newline;
13009       target_percent_s_newline[3] = '\0';
13010
13011       init = true;
13012     }
13013   return true;
13014 }
13015
13016 /* Helper function for do_mpfr_arg*().  Ensure M is a normal number
13017    and no overflow/underflow occurred.  INEXACT is true if M was not
13018    exactly calculated.  TYPE is the tree type for the result.  This
13019    function assumes that you cleared the MPFR flags and then
13020    calculated M to see if anything subsequently set a flag prior to
13021    entering this function.  Return NULL_TREE if any checks fail.  */
13022
13023 static tree
13024 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
13025 {
13026   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13027      overflow/underflow occurred.  If -frounding-math, proceed iff the
13028      result of calling FUNC was exact.  */
13029   if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
13030       && (!flag_rounding_math || !inexact))
13031     {
13032       REAL_VALUE_TYPE rr;
13033
13034       real_from_mpfr (&rr, m, type, GMP_RNDN);
13035       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
13036          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
13037          but the mpft_t is not, then we underflowed in the
13038          conversion.  */
13039       if (real_isfinite (&rr)
13040           && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
13041         {
13042           REAL_VALUE_TYPE rmode;
13043
13044           real_convert (&rmode, TYPE_MODE (type), &rr);
13045           /* Proceed iff the specified mode can hold the value.  */
13046           if (real_identical (&rmode, &rr))
13047             return build_real (type, rmode);
13048         }
13049     }
13050   return NULL_TREE;
13051 }
13052
13053 #ifdef HAVE_mpc
13054 /* Helper function for do_mpc_arg*().  Ensure M is a normal complex
13055    number and no overflow/underflow occurred.  INEXACT is true if M
13056    was not exactly calculated.  TYPE is the tree type for the result.
13057    This function assumes that you cleared the MPFR flags and then
13058    calculated M to see if anything subsequently set a flag prior to
13059    entering this function.  Return NULL_TREE if any checks fail, if
13060    FORCE_CONVERT is true, then bypass the checks.  */
13061
13062 static tree
13063 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
13064 {
13065   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13066      overflow/underflow occurred.  If -frounding-math, proceed iff the
13067      result of calling FUNC was exact.  */
13068   if (force_convert
13069       || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
13070           && !mpfr_overflow_p () && !mpfr_underflow_p ()
13071           && (!flag_rounding_math || !inexact)))
13072     {
13073       REAL_VALUE_TYPE re, im;
13074
13075       real_from_mpfr (&re, mpc_realref (m), type, GMP_RNDN);
13076       real_from_mpfr (&im, mpc_imagref (m), type, GMP_RNDN);
13077       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
13078          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
13079          but the mpft_t is not, then we underflowed in the
13080          conversion.  */
13081       if (force_convert
13082           || (real_isfinite (&re) && real_isfinite (&im)
13083               && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
13084               && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
13085         {
13086           REAL_VALUE_TYPE re_mode, im_mode;
13087
13088           real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
13089           real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
13090           /* Proceed iff the specified mode can hold the value.  */
13091           if (force_convert
13092               || (real_identical (&re_mode, &re)
13093                   && real_identical (&im_mode, &im)))
13094             return build_complex (type, build_real (TREE_TYPE (type), re_mode),
13095                                   build_real (TREE_TYPE (type), im_mode));
13096         }
13097     }
13098   return NULL_TREE;
13099 }
13100 #endif /* HAVE_mpc */
13101
13102 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
13103    FUNC on it and return the resulting value as a tree with type TYPE.
13104    If MIN and/or MAX are not NULL, then the supplied ARG must be
13105    within those bounds.  If INCLUSIVE is true, then MIN/MAX are
13106    acceptable values, otherwise they are not.  The mpfr precision is
13107    set to the precision of TYPE.  We assume that function FUNC returns
13108    zero if the result could be calculated exactly within the requested
13109    precision.  */
13110
13111 static tree
13112 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
13113               const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
13114               bool inclusive)
13115 {
13116   tree result = NULL_TREE;
13117
13118   STRIP_NOPS (arg);
13119
13120   /* To proceed, MPFR must exactly represent the target floating point
13121      format, which only happens when the target base equals two.  */
13122   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13123       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13124     {
13125       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13126
13127       if (real_isfinite (ra)
13128           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13129           && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13130         {
13131           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13132           const int prec = fmt->p;
13133           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13134           int inexact;
13135           mpfr_t m;
13136
13137           mpfr_init2 (m, prec);
13138           mpfr_from_real (m, ra, GMP_RNDN);
13139           mpfr_clear_flags ();
13140           inexact = func (m, m, rnd);
13141           result = do_mpfr_ckconv (m, type, inexact);
13142           mpfr_clear (m);
13143         }
13144     }
13145
13146   return result;
13147 }
13148
13149 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13150    FUNC on it and return the resulting value as a tree with type TYPE.
13151    The mpfr precision is set to the precision of TYPE.  We assume that
13152    function FUNC returns zero if the result could be calculated
13153    exactly within the requested precision.  */
13154
13155 static tree
13156 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13157               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13158 {
13159   tree result = NULL_TREE;
13160
13161   STRIP_NOPS (arg1);
13162   STRIP_NOPS (arg2);
13163
13164   /* To proceed, MPFR must exactly represent the target floating point
13165      format, which only happens when the target base equals two.  */
13166   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13167       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13168       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13169     {
13170       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13171       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13172
13173       if (real_isfinite (ra1) && real_isfinite (ra2))
13174         {
13175           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13176           const int prec = fmt->p;
13177           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13178           int inexact;
13179           mpfr_t m1, m2;
13180
13181           mpfr_inits2 (prec, m1, m2, NULL);
13182           mpfr_from_real (m1, ra1, GMP_RNDN);
13183           mpfr_from_real (m2, ra2, GMP_RNDN);
13184           mpfr_clear_flags ();
13185           inexact = func (m1, m1, m2, rnd);
13186           result = do_mpfr_ckconv (m1, type, inexact);
13187           mpfr_clears (m1, m2, NULL);
13188         }
13189     }
13190
13191   return result;
13192 }
13193
13194 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13195    FUNC on it and return the resulting value as a tree with type TYPE.
13196    The mpfr precision is set to the precision of TYPE.  We assume that
13197    function FUNC returns zero if the result could be calculated
13198    exactly within the requested precision.  */
13199
13200 static tree
13201 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13202               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13203 {
13204   tree result = NULL_TREE;
13205
13206   STRIP_NOPS (arg1);
13207   STRIP_NOPS (arg2);
13208   STRIP_NOPS (arg3);
13209
13210   /* To proceed, MPFR must exactly represent the target floating point
13211      format, which only happens when the target base equals two.  */
13212   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13213       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13214       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13215       && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13216     {
13217       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13218       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13219       const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13220
13221       if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13222         {
13223           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13224           const int prec = fmt->p;
13225           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13226           int inexact;
13227           mpfr_t m1, m2, m3;
13228
13229           mpfr_inits2 (prec, m1, m2, m3, NULL);
13230           mpfr_from_real (m1, ra1, GMP_RNDN);
13231           mpfr_from_real (m2, ra2, GMP_RNDN);
13232           mpfr_from_real (m3, ra3, GMP_RNDN);
13233           mpfr_clear_flags ();
13234           inexact = func (m1, m1, m2, m3, rnd);
13235           result = do_mpfr_ckconv (m1, type, inexact);
13236           mpfr_clears (m1, m2, m3, NULL);
13237         }
13238     }
13239
13240   return result;
13241 }
13242
13243 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13244    the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13245    If ARG_SINP and ARG_COSP are NULL then the result is returned
13246    as a complex value.
13247    The type is taken from the type of ARG and is used for setting the
13248    precision of the calculation and results.  */
13249
13250 static tree
13251 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13252 {
13253   tree const type = TREE_TYPE (arg);
13254   tree result = NULL_TREE;
13255
13256   STRIP_NOPS (arg);
13257
13258   /* To proceed, MPFR must exactly represent the target floating point
13259      format, which only happens when the target base equals two.  */
13260   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13261       && TREE_CODE (arg) == REAL_CST
13262       && !TREE_OVERFLOW (arg))
13263     {
13264       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13265
13266       if (real_isfinite (ra))
13267         {
13268           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13269           const int prec = fmt->p;
13270           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13271           tree result_s, result_c;
13272           int inexact;
13273           mpfr_t m, ms, mc;
13274
13275           mpfr_inits2 (prec, m, ms, mc, NULL);
13276           mpfr_from_real (m, ra, GMP_RNDN);
13277           mpfr_clear_flags ();
13278           inexact = mpfr_sin_cos (ms, mc, m, rnd);
13279           result_s = do_mpfr_ckconv (ms, type, inexact);
13280           result_c = do_mpfr_ckconv (mc, type, inexact);
13281           mpfr_clears (m, ms, mc, NULL);
13282           if (result_s && result_c)
13283             {
13284               /* If we are to return in a complex value do so.  */
13285               if (!arg_sinp && !arg_cosp)
13286                 return build_complex (build_complex_type (type),
13287                                       result_c, result_s);
13288
13289               /* Dereference the sin/cos pointer arguments.  */
13290               arg_sinp = build_fold_indirect_ref (arg_sinp);
13291               arg_cosp = build_fold_indirect_ref (arg_cosp);
13292               /* Proceed if valid pointer type were passed in.  */
13293               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13294                   && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13295                 {
13296                   /* Set the values. */
13297                   result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13298                                           result_s);
13299                   TREE_SIDE_EFFECTS (result_s) = 1;
13300                   result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13301                                           result_c);
13302                   TREE_SIDE_EFFECTS (result_c) = 1;
13303                   /* Combine the assignments into a compound expr.  */
13304                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13305                                                     result_s, result_c));
13306                 }
13307             }
13308         }
13309     }
13310   return result;
13311 }
13312
13313 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13314    two-argument mpfr order N Bessel function FUNC on them and return
13315    the resulting value as a tree with type TYPE.  The mpfr precision
13316    is set to the precision of TYPE.  We assume that function FUNC
13317    returns zero if the result could be calculated exactly within the
13318    requested precision.  */
13319 static tree
13320 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13321                   int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13322                   const REAL_VALUE_TYPE *min, bool inclusive)
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       && host_integerp (arg1, 0)
13333       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13334     {
13335       const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13336       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13337
13338       if (n == (long)n
13339           && real_isfinite (ra)
13340           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13341         {
13342           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13343           const int prec = fmt->p;
13344           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13345           int inexact;
13346           mpfr_t m;
13347
13348           mpfr_init2 (m, prec);
13349           mpfr_from_real (m, ra, GMP_RNDN);
13350           mpfr_clear_flags ();
13351           inexact = func (m, n, m, rnd);
13352           result = do_mpfr_ckconv (m, type, inexact);
13353           mpfr_clear (m);
13354         }
13355     }
13356
13357   return result;
13358 }
13359
13360 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13361    the pointer *(ARG_QUO) and return the result.  The type is taken
13362    from the type of ARG0 and is used for setting the precision of the
13363    calculation and results.  */
13364
13365 static tree
13366 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13367 {
13368   tree const type = TREE_TYPE (arg0);
13369   tree result = NULL_TREE;
13370
13371   STRIP_NOPS (arg0);
13372   STRIP_NOPS (arg1);
13373
13374   /* To proceed, MPFR must exactly represent the target floating point
13375      format, which only happens when the target base equals two.  */
13376   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13377       && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13378       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13379     {
13380       const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13381       const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13382
13383       if (real_isfinite (ra0) && real_isfinite (ra1))
13384         {
13385           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13386           const int prec = fmt->p;
13387           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13388           tree result_rem;
13389           long integer_quo;
13390           mpfr_t m0, m1;
13391
13392           mpfr_inits2 (prec, m0, m1, NULL);
13393           mpfr_from_real (m0, ra0, GMP_RNDN);
13394           mpfr_from_real (m1, ra1, GMP_RNDN);
13395           mpfr_clear_flags ();
13396           mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13397           /* Remquo is independent of the rounding mode, so pass
13398              inexact=0 to do_mpfr_ckconv().  */
13399           result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13400           mpfr_clears (m0, m1, NULL);
13401           if (result_rem)
13402             {
13403               /* MPFR calculates quo in the host's long so it may
13404                  return more bits in quo than the target int can hold
13405                  if sizeof(host long) > sizeof(target int).  This can
13406                  happen even for native compilers in LP64 mode.  In
13407                  these cases, modulo the quo value with the largest
13408                  number that the target int can hold while leaving one
13409                  bit for the sign.  */
13410               if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13411                 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13412
13413               /* Dereference the quo pointer argument.  */
13414               arg_quo = build_fold_indirect_ref (arg_quo);
13415               /* Proceed iff a valid pointer type was passed in.  */
13416               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13417                 {
13418                   /* Set the value. */
13419                   tree result_quo = fold_build2 (MODIFY_EXPR,
13420                                                  TREE_TYPE (arg_quo), arg_quo,
13421                                                  build_int_cst (NULL, integer_quo));
13422                   TREE_SIDE_EFFECTS (result_quo) = 1;
13423                   /* Combine the quo assignment with the rem.  */
13424                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13425                                                     result_quo, result_rem));
13426                 }
13427             }
13428         }
13429     }
13430   return result;
13431 }
13432
13433 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13434    resulting value as a tree with type TYPE.  The mpfr precision is
13435    set to the precision of TYPE.  We assume that this mpfr function
13436    returns zero if the result could be calculated exactly within the
13437    requested precision.  In addition, the integer pointer represented
13438    by ARG_SG will be dereferenced and set to the appropriate signgam
13439    (-1,1) value.  */
13440
13441 static tree
13442 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13443 {
13444   tree result = NULL_TREE;
13445
13446   STRIP_NOPS (arg);
13447
13448   /* To proceed, MPFR must exactly represent the target floating point
13449      format, which only happens when the target base equals two.  Also
13450      verify ARG is a constant and that ARG_SG is an int pointer.  */
13451   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13452       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13453       && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13454       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13455     {
13456       const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13457
13458       /* In addition to NaN and Inf, the argument cannot be zero or a
13459          negative integer.  */
13460       if (real_isfinite (ra)
13461           && ra->cl != rvc_zero
13462           && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13463         {
13464           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13465           const int prec = fmt->p;
13466           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13467           int inexact, sg;
13468           mpfr_t m;
13469           tree result_lg;
13470
13471           mpfr_init2 (m, prec);
13472           mpfr_from_real (m, ra, GMP_RNDN);
13473           mpfr_clear_flags ();
13474           inexact = mpfr_lgamma (m, &sg, m, rnd);
13475           result_lg = do_mpfr_ckconv (m, type, inexact);
13476           mpfr_clear (m);
13477           if (result_lg)
13478             {
13479               tree result_sg;
13480
13481               /* Dereference the arg_sg pointer argument.  */
13482               arg_sg = build_fold_indirect_ref (arg_sg);
13483               /* Assign the signgam value into *arg_sg. */
13484               result_sg = fold_build2 (MODIFY_EXPR,
13485                                        TREE_TYPE (arg_sg), arg_sg,
13486                                        build_int_cst (NULL, sg));
13487               TREE_SIDE_EFFECTS (result_sg) = 1;
13488               /* Combine the signgam assignment with the lgamma result.  */
13489               result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13490                                                 result_sg, result_lg));
13491             }
13492         }
13493     }
13494
13495   return result;
13496 }
13497
13498 #ifdef HAVE_mpc
13499 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13500    function FUNC on it and return the resulting value as a tree with
13501    type TYPE.  The mpfr precision is set to the precision of TYPE.  We
13502    assume that function FUNC returns zero if the result could be
13503    calculated exactly within the requested precision.  */
13504
13505 static tree
13506 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13507 {
13508   tree result = NULL_TREE;
13509
13510   STRIP_NOPS (arg);
13511
13512   /* To proceed, MPFR must exactly represent the target floating point
13513      format, which only happens when the target base equals two.  */
13514   if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
13515       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
13516       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
13517     {
13518       const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
13519       const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
13520
13521       if (real_isfinite (re) && real_isfinite (im))
13522         {
13523           const struct real_format *const fmt =
13524             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13525           const int prec = fmt->p;
13526           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13527           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13528           int inexact;
13529           mpc_t m;
13530
13531           mpc_init2 (m, prec);
13532           mpfr_from_real (mpc_realref(m), re, rnd);
13533           mpfr_from_real (mpc_imagref(m), im, rnd);
13534           mpfr_clear_flags ();
13535           inexact = func (m, m, crnd);
13536           result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
13537           mpc_clear (m);
13538         }
13539     }
13540
13541   return result;
13542 }
13543
13544 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
13545    mpc function FUNC on it and return the resulting value as a tree
13546    with type TYPE.  The mpfr precision is set to the precision of
13547    TYPE.  We assume that function FUNC returns zero if the result
13548    could be calculated exactly within the requested precision.  If
13549    DO_NONFINITE is true, then fold expressions containing Inf or NaN
13550    in the arguments and/or results.  */
13551
13552 #ifdef HAVE_mpc
13553 tree
13554 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
13555              int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
13556 {
13557   tree result = NULL_TREE;
13558
13559   STRIP_NOPS (arg0);
13560   STRIP_NOPS (arg1);
13561
13562   /* To proceed, MPFR must exactly represent the target floating point
13563      format, which only happens when the target base equals two.  */
13564   if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
13565       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
13566       && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
13567       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
13568       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
13569     {
13570       const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
13571       const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
13572       const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
13573       const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
13574
13575       if (do_nonfinite
13576           || (real_isfinite (re0) && real_isfinite (im0)
13577               && real_isfinite (re1) && real_isfinite (im1)))
13578         {
13579           const struct real_format *const fmt =
13580             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13581           const int prec = fmt->p;
13582           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13583           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13584           int inexact;
13585           mpc_t m0, m1;
13586
13587           mpc_init2 (m0, prec);
13588           mpc_init2 (m1, prec);
13589           mpfr_from_real (mpc_realref(m0), re0, rnd);
13590           mpfr_from_real (mpc_imagref(m0), im0, rnd);
13591           mpfr_from_real (mpc_realref(m1), re1, rnd);
13592           mpfr_from_real (mpc_imagref(m1), im1, rnd);
13593           mpfr_clear_flags ();
13594           inexact = func (m0, m0, m1, crnd);
13595           result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
13596           mpc_clear (m0);
13597           mpc_clear (m1);
13598         }
13599     }
13600
13601   return result;
13602 }
13603 # endif
13604 #endif /* HAVE_mpc */
13605
13606 /* FIXME tuples.
13607    The functions below provide an alternate interface for folding
13608    builtin function calls presented as GIMPLE_CALL statements rather
13609    than as CALL_EXPRs.  The folded result is still expressed as a
13610    tree.  There is too much code duplication in the handling of
13611    varargs functions, and a more intrusive re-factoring would permit
13612    better sharing of code between the tree and statement-based
13613    versions of these functions.  */
13614
13615 /* Construct a new CALL_EXPR using the tail of the argument list of STMT
13616    along with N new arguments specified as the "..." parameters.  SKIP
13617    is the number of arguments in STMT to be omitted.  This function is used
13618    to do varargs-to-varargs transformations.  */
13619
13620 static tree
13621 gimple_rewrite_call_expr (gimple stmt, int skip, tree fndecl, int n, ...)
13622 {
13623   int oldnargs = gimple_call_num_args (stmt);
13624   int nargs = oldnargs - skip + n;
13625   tree fntype = TREE_TYPE (fndecl);
13626   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
13627   tree *buffer;
13628   int i, j;
13629   va_list ap;
13630   location_t loc = gimple_location (stmt);
13631
13632   buffer = XALLOCAVEC (tree, nargs);
13633   va_start (ap, n);
13634   for (i = 0; i < n; i++)
13635     buffer[i] = va_arg (ap, tree);
13636   va_end (ap);
13637   for (j = skip; j < oldnargs; j++, i++)
13638     buffer[i] = gimple_call_arg (stmt, j);
13639
13640   return fold (build_call_array_loc (loc, TREE_TYPE (fntype), fn, nargs, buffer));
13641 }
13642
13643 /* Fold a call STMT to __{,v}sprintf_chk.  Return NULL_TREE if
13644    a normal call should be emitted rather than expanding the function
13645    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
13646
13647 static tree
13648 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
13649 {
13650   tree dest, size, len, fn, fmt, flag;
13651   const char *fmt_str;
13652   int nargs = gimple_call_num_args (stmt);
13653
13654   /* Verify the required arguments in the original call.  */
13655   if (nargs < 4)
13656     return NULL_TREE;
13657   dest = gimple_call_arg (stmt, 0);
13658   if (!validate_arg (dest, POINTER_TYPE))
13659     return NULL_TREE;
13660   flag = gimple_call_arg (stmt, 1);
13661   if (!validate_arg (flag, INTEGER_TYPE))
13662     return NULL_TREE;
13663   size = gimple_call_arg (stmt, 2);
13664   if (!validate_arg (size, INTEGER_TYPE))
13665     return NULL_TREE;
13666   fmt = gimple_call_arg (stmt, 3);
13667   if (!validate_arg (fmt, POINTER_TYPE))
13668     return NULL_TREE;
13669
13670   if (! host_integerp (size, 1))
13671     return NULL_TREE;
13672
13673   len = NULL_TREE;
13674
13675   if (!init_target_chars ())
13676     return NULL_TREE;
13677
13678   /* Check whether the format is a literal string constant.  */
13679   fmt_str = c_getstr (fmt);
13680   if (fmt_str != NULL)
13681     {
13682       /* If the format doesn't contain % args or %%, we know the size.  */
13683       if (strchr (fmt_str, target_percent) == 0)
13684         {
13685           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
13686             len = build_int_cstu (size_type_node, strlen (fmt_str));
13687         }
13688       /* If the format is "%s" and first ... argument is a string literal,
13689          we know the size too.  */
13690       else if (fcode == BUILT_IN_SPRINTF_CHK
13691                && strcmp (fmt_str, target_percent_s) == 0)
13692         {
13693           tree arg;
13694
13695           if (nargs == 5)
13696             {
13697               arg = gimple_call_arg (stmt, 4);
13698               if (validate_arg (arg, POINTER_TYPE))
13699                 {
13700                   len = c_strlen (arg, 1);
13701                   if (! len || ! host_integerp (len, 1))
13702                     len = NULL_TREE;
13703                 }
13704             }
13705         }
13706     }
13707
13708   if (! integer_all_onesp (size))
13709     {
13710       if (! len || ! tree_int_cst_lt (len, size))
13711         return NULL_TREE;
13712     }
13713
13714   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13715      or if format doesn't contain % chars or is "%s".  */
13716   if (! integer_zerop (flag))
13717     {
13718       if (fmt_str == NULL)
13719         return NULL_TREE;
13720       if (strchr (fmt_str, target_percent) != NULL
13721           && strcmp (fmt_str, target_percent_s))
13722         return NULL_TREE;
13723     }
13724
13725   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
13726   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
13727                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
13728   if (!fn)
13729     return NULL_TREE;
13730
13731   return gimple_rewrite_call_expr (stmt, 4, fn, 2, dest, fmt);
13732 }
13733
13734 /* Fold a call STMT to {,v}snprintf.  Return NULL_TREE if
13735    a normal call should be emitted rather than expanding the function
13736    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
13737    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
13738    passed as second argument.  */
13739
13740 tree
13741 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
13742                                   enum built_in_function fcode)
13743 {
13744   tree dest, size, len, fn, fmt, flag;
13745   const char *fmt_str;
13746
13747   /* Verify the required arguments in the original call.  */
13748   if (gimple_call_num_args (stmt) < 5)
13749     return NULL_TREE;
13750   dest = gimple_call_arg (stmt, 0);
13751   if (!validate_arg (dest, POINTER_TYPE))
13752     return NULL_TREE;
13753   len = gimple_call_arg (stmt, 1);
13754   if (!validate_arg (len, INTEGER_TYPE))
13755     return NULL_TREE;
13756   flag = gimple_call_arg (stmt, 2);
13757   if (!validate_arg (flag, INTEGER_TYPE))
13758     return NULL_TREE;
13759   size = gimple_call_arg (stmt, 3);
13760   if (!validate_arg (size, INTEGER_TYPE))
13761     return NULL_TREE;
13762   fmt = gimple_call_arg (stmt, 4);
13763   if (!validate_arg (fmt, POINTER_TYPE))
13764     return NULL_TREE;
13765
13766   if (! host_integerp (size, 1))
13767     return NULL_TREE;
13768
13769   if (! integer_all_onesp (size))
13770     {
13771       if (! host_integerp (len, 1))
13772         {
13773           /* If LEN is not constant, try MAXLEN too.
13774              For MAXLEN only allow optimizing into non-_ocs function
13775              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
13776           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
13777             return NULL_TREE;
13778         }
13779       else
13780         maxlen = len;
13781
13782       if (tree_int_cst_lt (size, maxlen))
13783         return NULL_TREE;
13784     }
13785
13786   if (!init_target_chars ())
13787     return NULL_TREE;
13788
13789   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13790      or if format doesn't contain % chars or is "%s".  */
13791   if (! integer_zerop (flag))
13792     {
13793       fmt_str = c_getstr (fmt);
13794       if (fmt_str == NULL)
13795         return NULL_TREE;
13796       if (strchr (fmt_str, target_percent) != NULL
13797           && strcmp (fmt_str, target_percent_s))
13798         return NULL_TREE;
13799     }
13800
13801   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13802      available.  */
13803   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
13804                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
13805   if (!fn)
13806     return NULL_TREE;
13807
13808   return gimple_rewrite_call_expr (stmt, 5, fn, 3, dest, len, fmt);
13809 }
13810
13811 /* Builtins with folding operations that operate on "..." arguments
13812    need special handling; we need to store the arguments in a convenient
13813    data structure before attempting any folding.  Fortunately there are
13814    only a few builtins that fall into this category.  FNDECL is the
13815    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13816    result of the function call is ignored.  */
13817
13818 static tree
13819 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
13820                              bool ignore ATTRIBUTE_UNUSED)
13821 {
13822   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13823   tree ret = NULL_TREE;
13824
13825   switch (fcode)
13826     {
13827     case BUILT_IN_SPRINTF_CHK:
13828     case BUILT_IN_VSPRINTF_CHK:
13829       ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
13830       break;
13831
13832     case BUILT_IN_SNPRINTF_CHK:
13833     case BUILT_IN_VSNPRINTF_CHK:
13834       ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
13835
13836     default:
13837       break;
13838     }
13839   if (ret)
13840     {
13841       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
13842       TREE_NO_WARNING (ret) = 1;
13843       return ret;
13844     }
13845   return NULL_TREE;
13846 }
13847
13848 /* A wrapper function for builtin folding that prevents warnings for
13849    "statement without effect" and the like, caused by removing the
13850    call node earlier than the warning is generated.  */
13851
13852 tree
13853 fold_call_stmt (gimple stmt, bool ignore)
13854 {
13855   tree ret = NULL_TREE;
13856   tree fndecl = gimple_call_fndecl (stmt);
13857   location_t loc = gimple_location (stmt);
13858   if (fndecl
13859       && TREE_CODE (fndecl) == FUNCTION_DECL
13860       && DECL_BUILT_IN (fndecl)
13861       && !gimple_call_va_arg_pack_p (stmt))
13862     {
13863       int nargs = gimple_call_num_args (stmt);
13864
13865       if (avoid_folding_inline_builtin (fndecl))
13866         return NULL_TREE;
13867       /* FIXME: Don't use a list in this interface.  */
13868       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
13869         {
13870           tree arglist = NULL_TREE;
13871           int i;
13872           for (i = nargs - 1; i >= 0; i--)
13873             arglist = tree_cons (NULL_TREE, gimple_call_arg (stmt, i), arglist);
13874           return targetm.fold_builtin (fndecl, arglist, ignore);
13875         }
13876       else
13877         {
13878           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
13879             {
13880               tree args[MAX_ARGS_TO_FOLD_BUILTIN];
13881               int i;
13882               for (i = 0; i < nargs; i++)
13883                 args[i] = gimple_call_arg (stmt, i);
13884               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
13885             }
13886           if (!ret)
13887             ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
13888           if (ret)
13889             {
13890               /* Propagate location information from original call to
13891                  expansion of builtin.  Otherwise things like
13892                  maybe_emit_chk_warning, that operate on the expansion
13893                  of a builtin, will use the wrong location information.  */
13894               if (gimple_has_location (stmt))
13895                 {
13896                   tree realret = ret;
13897                   if (TREE_CODE (ret) == NOP_EXPR)
13898                     realret = TREE_OPERAND (ret, 0);
13899                   if (CAN_HAVE_LOCATION_P (realret)
13900                       && !EXPR_HAS_LOCATION (realret))
13901                     SET_EXPR_LOCATION (realret, loc);
13902                   return realret;
13903                 }
13904               return ret;
13905             }
13906         }
13907     }
13908   return NULL_TREE;
13909 }
13910
13911 /* Look up the function in built_in_decls that corresponds to DECL
13912    and set ASMSPEC as its user assembler name.  DECL must be a
13913    function decl that declares a builtin.  */
13914
13915 void
13916 set_builtin_user_assembler_name (tree decl, const char *asmspec)
13917 {
13918   tree builtin;
13919   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
13920               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
13921               && asmspec != 0);
13922
13923   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
13924   set_user_assembler_name (builtin, asmspec);
13925   switch (DECL_FUNCTION_CODE (decl))
13926     {
13927     case BUILT_IN_MEMCPY:
13928       init_block_move_fn (asmspec);
13929       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
13930       break;
13931     case BUILT_IN_MEMSET:
13932       init_block_clear_fn (asmspec);
13933       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
13934       break;
13935     case BUILT_IN_MEMMOVE:
13936       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
13937       break;
13938     case BUILT_IN_MEMCMP:
13939       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
13940       break;
13941     case BUILT_IN_ABORT:
13942       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
13943       break;
13944     default:
13945       break;
13946     }
13947 }