gcc/builtins.c

   1 /* Expand builtin functions.
   2    Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "machmode.h"
  27 #include "rtl.h"
  28 #include "tree.h"
  29 #include "realmpfr.h"
  30 #include "gimple.h"
  31 #include "flags.h"
  32 #include "regs.h"
  33 #include "hard-reg-set.h"
  34 #include "except.h"
  35 #include "function.h"
  36 #include "insn-config.h"
  37 #include "expr.h"
  38 #include "optabs.h"
  39 #include "libfuncs.h"
  40 #include "recog.h"
  41 #include "output.h"
  42 #include "typeclass.h"
  43 #include "toplev.h"
  44 #include "predict.h"
  45 #include "tm_p.h"
  46 #include "target.h"
  47 #include "langhooks.h"
  48 #include "basic-block.h"
  49 #include "tree-mudflap.h"
  50 #include "tree-flow.h"
  51 #include "value-prof.h"
  52 #include "diagnostic-core.h"
  53 #include "builtins.h"
  54
  55 #ifndef SLOW_UNALIGNED_ACCESS
  56 #define SLOW_UNALIGNED_ACCESS(MODE, ALIGN) STRICT_ALIGNMENT
  57 #endif
  58
  59 #ifndef PAD_VARARGS_DOWN
  60 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
  61 #endif
  62 static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));
  63
  64 struct target_builtins default_target_builtins;
  65 #if SWITCHABLE_TARGET
  66 struct target_builtins *this_target_builtins = &default_target_builtins;
  67 #endif
  68
  69 /* Define the names of the builtin function types and codes.  */
  70 const char *const built_in_class_names[4]
  71   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
  72
  73 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
  74 const char * built_in_names[(int) END_BUILTINS] =
  75 {
  76 #include "builtins.def"
  77 };
  78 #undef DEF_BUILTIN
  79
  80 /* Setup an array of _DECL trees, make sure each element is
  81    initialized to NULL_TREE.  */
  82 tree built_in_decls[(int) END_BUILTINS];
  83 /* Declarations used when constructing the builtin implicitly in the compiler.
  84    It may be NULL_TREE when this is invalid (for instance runtime is not
  85    required to implement the function call in all cases).  */
  86 tree implicit_built_in_decls[(int) END_BUILTINS];
  87
  88 static const char *c_getstr (tree);
  89 static rtx c_readstr (const char *, enum machine_mode);
  90 static int target_char_cast (tree, char *);
  91 static rtx get_memory_rtx (tree, tree);
  92 static int apply_args_size (void);
  93 static int apply_result_size (void);
  94 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
  95 static rtx result_vector (int, rtx);
  96 #endif
  97 static void expand_builtin_update_setjmp_buf (rtx);
  98 static void expand_builtin_prefetch (tree);
  99 static rtx expand_builtin_apply_args (void);
 100 static rtx expand_builtin_apply_args_1 (void);
 101 static rtx expand_builtin_apply (rtx, rtx, rtx);
 102 static void expand_builtin_return (rtx);
 103 static enum type_class type_to_class (tree);
 104 static rtx expand_builtin_classify_type (tree);
 105 static void expand_errno_check (tree, rtx);
 106 static rtx expand_builtin_mathfn (tree, rtx, rtx);
 107 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
 108 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
 109 static rtx expand_builtin_interclass_mathfn (tree, rtx);
 110 static rtx expand_builtin_sincos (tree);
 111 static rtx expand_builtin_cexpi (tree, rtx);
 112 static rtx expand_builtin_int_roundingfn (tree, rtx);
 113 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
 114 static rtx expand_builtin_next_arg (void);
 115 static rtx expand_builtin_va_start (tree);
 116 static rtx expand_builtin_va_end (tree);
 117 static rtx expand_builtin_va_copy (tree);
 118 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
 119 static rtx expand_builtin_strcmp (tree, rtx);
 120 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
 121 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 122 static rtx expand_builtin_memcpy (tree, rtx);
 123 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
 124 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
 125                                         enum machine_mode, int);
 126 static rtx expand_builtin_strcpy (tree, rtx);
 127 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
 128 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
 129 static rtx expand_builtin_strncpy (tree, rtx);
 130 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
 131 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
 132 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
 133 static rtx expand_builtin_bzero (tree);
 134 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
 135 static rtx expand_builtin_alloca (tree, bool);
 136 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
 137 static rtx expand_builtin_frame_address (tree, tree);
 138 static tree stabilize_va_list_loc (location_t, tree, int);
 139 static rtx expand_builtin_expect (tree, rtx);
 140 static tree fold_builtin_constant_p (tree);
 141 static tree fold_builtin_expect (location_t, tree, tree);
 142 static tree fold_builtin_classify_type (tree);
 143 static tree fold_builtin_strlen (location_t, tree, tree);
 144 static tree fold_builtin_inf (location_t, tree, int);
 145 static tree fold_builtin_nan (tree, tree, int);
 146 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
 147 static bool validate_arg (const_tree, enum tree_code code);
 148 static bool integer_valued_real_p (tree);
 149 static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
 150 static bool readonly_data_expr (tree);
 151 static rtx expand_builtin_fabs (tree, rtx, rtx);
 152 static rtx expand_builtin_signbit (tree, rtx);
 153 static tree fold_builtin_sqrt (location_t, tree, tree);
 154 static tree fold_builtin_cbrt (location_t, tree, tree);
 155 static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
 156 static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
 157 static tree fold_builtin_cos (location_t, tree, tree, tree);
 158 static tree fold_builtin_cosh (location_t, tree, tree, tree);
 159 static tree fold_builtin_tan (tree, tree);
 160 static tree fold_builtin_trunc (location_t, tree, tree);
 161 static tree fold_builtin_floor (location_t, tree, tree);
 162 static tree fold_builtin_ceil (location_t, tree, tree);
 163 static tree fold_builtin_round (location_t, tree, tree);
 164 static tree fold_builtin_int_roundingfn (location_t, tree, tree);
 165 static tree fold_builtin_bitop (tree, tree);
 166 static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
 167 static tree fold_builtin_strchr (location_t, tree, tree, tree);
 168 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
 169 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
 170 static tree fold_builtin_strcmp (location_t, tree, tree);
 171 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
 172 static tree fold_builtin_signbit (location_t, tree, tree);
 173 static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
 174 static tree fold_builtin_isascii (location_t, tree);
 175 static tree fold_builtin_toascii (location_t, tree);
 176 static tree fold_builtin_isdigit (location_t, tree);
 177 static tree fold_builtin_fabs (location_t, tree, tree);
 178 static tree fold_builtin_abs (location_t, tree, tree);
 179 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
 180                                         enum tree_code);
 181 static tree fold_builtin_n (location_t, tree, tree *, int, bool);
 182 static tree fold_builtin_0 (location_t, tree, bool);
 183 static tree fold_builtin_1 (location_t, tree, tree, bool);
 184 static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
 185 static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
 186 static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
 187 static tree fold_builtin_varargs (location_t, tree, tree, bool);
 188
 189 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
 190 static tree fold_builtin_strstr (location_t, tree, tree, tree);
 191 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
 192 static tree fold_builtin_strcat (location_t, tree, tree);
 193 static tree fold_builtin_strncat (location_t, tree, tree, tree);
 194 static tree fold_builtin_strspn (location_t, tree, tree);
 195 static tree fold_builtin_strcspn (location_t, tree, tree);
 196 static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
 197
 198 static rtx expand_builtin_object_size (tree);
 199 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
 200                                       enum built_in_function);
 201 static void maybe_emit_chk_warning (tree, enum built_in_function);
 202 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 203 static void maybe_emit_free_warning (tree);
 204 static tree fold_builtin_object_size (tree, tree);
 205 static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
 206 static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
 207 static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
 208 static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
 209 static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
 210                                   enum built_in_function);
 211 static bool init_target_chars (void);
 212
 213 static unsigned HOST_WIDE_INT target_newline;
 214 static unsigned HOST_WIDE_INT target_percent;
 215 static unsigned HOST_WIDE_INT target_c;
 216 static unsigned HOST_WIDE_INT target_s;
 217 static char target_percent_c[3];
 218 static char target_percent_s[3];
 219 static char target_percent_s_newline[4];
 220 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
 221                           const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
 222 static tree do_mpfr_arg2 (tree, tree, tree,
 223                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 224 static tree do_mpfr_arg3 (tree, tree, tree, tree,
 225                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 226 static tree do_mpfr_sincos (tree, tree, tree);
 227 static tree do_mpfr_bessel_n (tree, tree, tree,
 228                               int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
 229                               const REAL_VALUE_TYPE *, bool);
 230 static tree do_mpfr_remquo (tree, tree, tree);
 231 static tree do_mpfr_lgamma_r (tree, tree, tree);
 232
 233 /* Return true if NAME starts with __builtin_ or __sync_.  */
 234
 235 bool
 236 is_builtin_name (const char *name)
 237 {
 238   if (strncmp (name, "__builtin_", 10) == 0)
 239     return true;
 240   if (strncmp (name, "__sync_", 7) == 0)
 241     return true;
 242   return false;
 243 }
 244
 245
 246 /* Return true if DECL is a function symbol representing a built-in.  */
 247
 248 bool
 249 is_builtin_fn (tree decl)
 250 {
 251   return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
 252 }
 253
 254
 255 /* Return true if NODE should be considered for inline expansion regardless
 256    of the optimization level.  This means whenever a function is invoked with
 257    its "internal" name, which normally contains the prefix "__builtin".  */
 258
 259 static bool
 260 called_as_built_in (tree node)
 261 {
 262   /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
 263      we want the name used to call the function, not the name it
 264      will have. */
 265   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 266   return is_builtin_name (name);
 267 }
 268
 269 /* Return the alignment in bits of EXP, an object.
 270    Don't return more than MAX_ALIGN no matter what.  */
 271
 272 unsigned int
 273 get_object_alignment (tree exp, unsigned int max_align)
 274 {
 275   HOST_WIDE_INT bitsize, bitpos;
 276   tree offset;
 277   enum machine_mode mode;
 278   int unsignedp, volatilep;
 279   unsigned int align, inner;
 280
 281   /* Get the innermost object and the constant (bitpos) and possibly
 282      variable (offset) offset of the access.  */
 283   exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
 284                              &mode, &unsignedp, &volatilep, true);
 285
 286   /* Extract alignment information from the innermost object and
 287      possibly adjust bitpos and offset.  */
 288   if (TREE_CODE (exp) == CONST_DECL)
 289     exp = DECL_INITIAL (exp);
 290   if (DECL_P (exp)
 291       && TREE_CODE (exp) != LABEL_DECL)
 292     align = DECL_ALIGN (exp);
 293   else if (CONSTANT_CLASS_P (exp))
 294     {
 295       align = TYPE_ALIGN (TREE_TYPE (exp));
 296 #ifdef CONSTANT_ALIGNMENT
 297       align = (unsigned)CONSTANT_ALIGNMENT (exp, align);
 298 #endif
 299     }
 300   else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
 301     align = TYPE_ALIGN (TREE_TYPE (exp));
 302   else if (TREE_CODE (exp) == INDIRECT_REF)
 303     align = TYPE_ALIGN (TREE_TYPE (exp));
 304   else if (TREE_CODE (exp) == MEM_REF)
 305     {
 306       tree addr = TREE_OPERAND (exp, 0);
 307       struct ptr_info_def *pi;
 308       if (TREE_CODE (addr) == BIT_AND_EXPR
 309           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 310         {
 311           align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 312                     & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 313           align *= BITS_PER_UNIT;
 314           addr = TREE_OPERAND (addr, 0);
 315         }
 316       else
 317         align = BITS_PER_UNIT;
 318       if (TREE_CODE (addr) == SSA_NAME
 319           && (pi = SSA_NAME_PTR_INFO (addr)))
 320         {
 321           bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
 322           align = MAX (pi->align * BITS_PER_UNIT, align);
 323         }
 324       else if (TREE_CODE (addr) == ADDR_EXPR)
 325         align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
 326                                                   max_align));
 327       bitpos += mem_ref_offset (exp).low * BITS_PER_UNIT;
 328     }
 329   else if (TREE_CODE (exp) == TARGET_MEM_REF)
 330     {
 331       struct ptr_info_def *pi;
 332       tree addr = TMR_BASE (exp);
 333       if (TREE_CODE (addr) == BIT_AND_EXPR
 334           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 335         {
 336           align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 337                    & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 338           align *= BITS_PER_UNIT;
 339           addr = TREE_OPERAND (addr, 0);
 340         }
 341       else
 342         align = BITS_PER_UNIT;
 343       if (TREE_CODE (addr) == SSA_NAME
 344           && (pi = SSA_NAME_PTR_INFO (addr)))
 345         {
 346           bitpos += (pi->misalign * BITS_PER_UNIT) & ~(align - 1);
 347           align = MAX (pi->align * BITS_PER_UNIT, align);
 348         }
 349       else if (TREE_CODE (addr) == ADDR_EXPR)
 350         align = MAX (align, get_object_alignment (TREE_OPERAND (addr, 0),
 351                                                   max_align));
 352       if (TMR_OFFSET (exp))
 353         bitpos += TREE_INT_CST_LOW (TMR_OFFSET (exp)) * BITS_PER_UNIT;
 354       if (TMR_INDEX (exp) && TMR_STEP (exp))
 355         {
 356           unsigned HOST_WIDE_INT step = TREE_INT_CST_LOW (TMR_STEP (exp));
 357           align = MIN (align, (step & -step) * BITS_PER_UNIT);
 358         }
 359       else if (TMR_INDEX (exp))
 360         align = BITS_PER_UNIT;
 361       if (TMR_INDEX2 (exp))
 362         align = BITS_PER_UNIT;
 363     }
 364   else
 365     align = BITS_PER_UNIT;
 366
 367   /* If there is a non-constant offset part extract the maximum
 368      alignment that can prevail.  */
 369   inner = max_align;
 370   while (offset)
 371     {
 372       tree next_offset;
 373
 374       if (TREE_CODE (offset) == PLUS_EXPR)
 375         {
 376           next_offset = TREE_OPERAND (offset, 0);
 377           offset = TREE_OPERAND (offset, 1);
 378         }
 379       else
 380         next_offset = NULL;
 381       if (host_integerp (offset, 1))
 382         {
 383           /* Any overflow in calculating offset_bits won't change
 384              the alignment.  */
 385           unsigned offset_bits
 386             = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
 387
 388           if (offset_bits)
 389             inner = MIN (inner, (offset_bits & -offset_bits));
 390         }
 391       else if (TREE_CODE (offset) == MULT_EXPR
 392                && host_integerp (TREE_OPERAND (offset, 1), 1))
 393         {
 394           /* Any overflow in calculating offset_factor won't change
 395              the alignment.  */
 396           unsigned offset_factor
 397             = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
 398                * BITS_PER_UNIT);
 399
 400           if (offset_factor)
 401             inner = MIN (inner, (offset_factor & -offset_factor));
 402         }
 403       else
 404         {
 405           inner = MIN (inner, BITS_PER_UNIT);
 406           break;
 407         }
 408       offset = next_offset;
 409     }
 410
 411   /* Alignment is innermost object alignment adjusted by the constant
 412      and non-constant offset parts.  */
 413   align = MIN (align, inner);
 414   bitpos = bitpos & (align - 1);
 415
 416   /* align and bitpos now specify known low bits of the pointer.
 417      ptr & (align - 1) == bitpos.  */
 418
 419   if (bitpos != 0)
 420     align = (bitpos & -bitpos);
 421
 422   return MIN (align, max_align);
 423 }
 424
 425 /* Returns true iff we can trust that alignment information has been
 426    calculated properly.  */
 427
 428 bool
 429 can_trust_pointer_alignment (void)
 430 {
 431   /* We rely on TER to compute accurate alignment information.  */
 432   return (optimize && flag_tree_ter);
 433 }
 434
 435 /* Return the alignment in bits of EXP, a pointer valued expression.
 436    But don't return more than MAX_ALIGN no matter what.
 437    The alignment returned is, by default, the alignment of the thing that
 438    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 439
 440    Otherwise, look at the expression to see if we can do better, i.e., if the
 441    expression is actually pointing at an object whose alignment is tighter.  */
 442
 443 unsigned int
 444 get_pointer_alignment (tree exp, unsigned int max_align)
 445 {
 446   STRIP_NOPS (exp);
 447
 448   if (TREE_CODE (exp) == ADDR_EXPR)
 449     return get_object_alignment (TREE_OPERAND (exp, 0), max_align);
 450   else if (TREE_CODE (exp) == SSA_NAME
 451            && POINTER_TYPE_P (TREE_TYPE (exp)))
 452     {
 453       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);
 454       unsigned align;
 455       if (!pi)
 456         return BITS_PER_UNIT;
 457       if (pi->misalign != 0)
 458         align = (pi->misalign & -pi->misalign);
 459       else
 460         align = pi->align;
 461       return MIN (max_align, align * BITS_PER_UNIT);
 462     }
 463
 464   return POINTER_TYPE_P (TREE_TYPE (exp)) ? BITS_PER_UNIT : 0;
 465 }
 466
 467 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 468    way, because it could contain a zero byte in the middle.
 469    TREE_STRING_LENGTH is the size of the character array, not the string.
 470
 471    ONLY_VALUE should be nonzero if the result is not going to be emitted
 472    into the instruction stream and zero if it is going to be expanded.
 473    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 474    is returned, otherwise NULL, since
 475    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
 476    evaluate the side-effects.
 477
 478    The value returned is of type `ssizetype'.
 479
 480    Unfortunately, string_constant can't access the values of const char
 481    arrays with initializers, so neither can we do so here.  */
 482
 483 tree
 484 c_strlen (tree src, int only_value)
 485 {
 486   tree offset_node;
 487   HOST_WIDE_INT offset;
 488   int max;
 489   const char *ptr;
 490   location_t loc;
 491
 492   STRIP_NOPS (src);
 493   if (TREE_CODE (src) == COND_EXPR
 494       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 495     {
 496       tree len1, len2;
 497
 498       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
 499       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
 500       if (tree_int_cst_equal (len1, len2))
 501         return len1;
 502     }
 503
 504   if (TREE_CODE (src) == COMPOUND_EXPR
 505       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 506     return c_strlen (TREE_OPERAND (src, 1), only_value);
 507
 508   if (EXPR_HAS_LOCATION (src))
 509     loc = EXPR_LOCATION (src);
 510   else
 511     loc = input_location;
 512
 513   src = string_constant (src, &offset_node);
 514   if (src == 0)
 515     return NULL_TREE;
 516
 517   max = TREE_STRING_LENGTH (src) - 1;
 518   ptr = TREE_STRING_POINTER (src);
 519
 520   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 521     {
 522       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 523          compute the offset to the following null if we don't know where to
 524          start searching for it.  */
 525       int i;
 526
 527       for (i = 0; i < max; i++)
 528         if (ptr[i] == 0)
 529           return NULL_TREE;
 530
 531       /* We don't know the starting offset, but we do know that the string
 532          has no internal zero bytes.  We can assume that the offset falls
 533          within the bounds of the string; otherwise, the programmer deserves
 534          what he gets.  Subtract the offset from the length of the string,
 535          and return that.  This would perhaps not be valid if we were dealing
 536          with named arrays in addition to literal string constants.  */
 537
 538       return size_diffop_loc (loc, size_int (max), offset_node);
 539     }
 540
 541   /* We have a known offset into the string.  Start searching there for
 542      a null character if we can represent it as a single HOST_WIDE_INT.  */
 543   if (offset_node == 0)
 544     offset = 0;
 545   else if (! host_integerp (offset_node, 0))
 546     offset = -1;
 547   else
 548     offset = tree_low_cst (offset_node, 0);
 549
 550   /* If the offset is known to be out of bounds, warn, and call strlen at
 551      runtime.  */
 552   if (offset < 0 || offset > max)
 553     {
 554      /* Suppress multiple warnings for propagated constant strings.  */
 555       if (! TREE_NO_WARNING (src))
 556         {
 557           warning_at (loc, 0, "offset outside bounds of constant string");
 558           TREE_NO_WARNING (src) = 1;
 559         }
 560       return NULL_TREE;
 561     }
 562
 563   /* Use strlen to search for the first zero byte.  Since any strings
 564      constructed with build_string will have nulls appended, we win even
 565      if we get handed something like (char[4])"abcd".
 566
 567      Since OFFSET is our starting index into the string, no further
 568      calculation is needed.  */
 569   return ssize_int (strlen (ptr + offset));
 570 }
 571
 572 /* Return a char pointer for a C string if it is a string constant
 573    or sum of string constant and integer constant.  */
 574
 575 static const char *
 576 c_getstr (tree src)
 577 {
 578   tree offset_node;
 579
 580   src = string_constant (src, &offset_node);
 581   if (src == 0)
 582     return 0;
 583
 584   if (offset_node == 0)
 585     return TREE_STRING_POINTER (src);
 586   else if (!host_integerp (offset_node, 1)
 587            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
 588     return 0;
 589
 590   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
 591 }
 592
 593 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
 594    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 595
 596 static rtx
 597 c_readstr (const char *str, enum machine_mode mode)
 598 {
 599   HOST_WIDE_INT c[2];
 600   HOST_WIDE_INT ch;
 601   unsigned int i, j;
 602
 603   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
 604
 605   c[0] = 0;
 606   c[1] = 0;
 607   ch = 1;
 608   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 609     {
 610       j = i;
 611       if (WORDS_BIG_ENDIAN)
 612         j = GET_MODE_SIZE (mode) - i - 1;
 613       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 614           && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
 615         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 616       j *= BITS_PER_UNIT;
 617       gcc_assert (j < 2 * HOST_BITS_PER_WIDE_INT);
 618
 619       if (ch)
 620         ch = (unsigned char) str[i];
 621       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 622     }
 623   return immed_double_const (c[0], c[1], mode);
 624 }
 625
 626 /* Cast a target constant CST to target CHAR and if that value fits into
 627    host char type, return zero and put that value into variable pointed to by
 628    P.  */
 629
 630 static int
 631 target_char_cast (tree cst, char *p)
 632 {
 633   unsigned HOST_WIDE_INT val, hostval;
 634
 635   if (!host_integerp (cst, 1)
 636       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 637     return 1;
 638
 639   val = tree_low_cst (cst, 1);
 640   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 641     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 642
 643   hostval = val;
 644   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 645     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 646
 647   if (val != hostval)
 648     return 1;
 649
 650   *p = hostval;
 651   return 0;
 652 }
 653
 654 /* Similar to save_expr, but assumes that arbitrary code is not executed
 655    in between the multiple evaluations.  In particular, we assume that a
 656    non-addressable local variable will not be modified.  */
 657
 658 static tree
 659 builtin_save_expr (tree exp)
 660 {
 661   if (TREE_ADDRESSABLE (exp) == 0
 662       && (TREE_CODE (exp) == PARM_DECL
 663           || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp))))
 664     return exp;
 665
 666   return save_expr (exp);
 667 }
 668
 669 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 670    times to get the address of either a higher stack frame, or a return
 671    address located within it (depending on FNDECL_CODE).  */
 672
 673 static rtx
 674 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
 675 {
 676   int i;
 677
 678 #ifdef INITIAL_FRAME_ADDRESS_RTX
 679   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
 680 #else
 681   rtx tem;
 682
 683   /* For a zero count with __builtin_return_address, we don't care what
 684      frame address we return, because target-specific definitions will
 685      override us.  Therefore frame pointer elimination is OK, and using
 686      the soft frame pointer is OK.
 687
 688      For a nonzero count, or a zero count with __builtin_frame_address,
 689      we require a stable offset from the current frame pointer to the
 690      previous one, so we must use the hard frame pointer, and
 691      we must disable frame pointer elimination.  */
 692   if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
 693     tem = frame_pointer_rtx;
 694   else
 695     {
 696       tem = hard_frame_pointer_rtx;
 697
 698       /* Tell reload not to eliminate the frame pointer.  */
 699       crtl->accesses_prior_frames = 1;
 700     }
 701 #endif
 702
 703   /* Some machines need special handling before we can access
 704      arbitrary frames.  For example, on the SPARC, we must first flush
 705      all register windows to the stack.  */
 706 #ifdef SETUP_FRAME_ADDRESSES
 707   if (count > 0)
 708     SETUP_FRAME_ADDRESSES ();
 709 #endif
 710
 711   /* On the SPARC, the return address is not in the frame, it is in a
 712      register.  There is no way to access it off of the current frame
 713      pointer, but it can be accessed off the previous frame pointer by
 714      reading the value from the register window save area.  */
 715 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
 716   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
 717     count--;
 718 #endif
 719
 720   /* Scan back COUNT frames to the specified frame.  */
 721   for (i = 0; i < count; i++)
 722     {
 723       /* Assume the dynamic chain pointer is in the word that the
 724          frame address points to, unless otherwise specified.  */
 725 #ifdef DYNAMIC_CHAIN_ADDRESS
 726       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 727 #endif
 728       tem = memory_address (Pmode, tem);
 729       tem = gen_frame_mem (Pmode, tem);
 730       tem = copy_to_reg (tem);
 731     }
 732
 733   /* For __builtin_frame_address, return what we've got.  But, on
 734      the SPARC for example, we may have to add a bias.  */
 735   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 736 #ifdef FRAME_ADDR_RTX
 737     return FRAME_ADDR_RTX (tem);
 738 #else
 739     return tem;
 740 #endif
 741
 742   /* For __builtin_return_address, get the return address from that frame.  */
 743 #ifdef RETURN_ADDR_RTX
 744   tem = RETURN_ADDR_RTX (count, tem);
 745 #else
 746   tem = memory_address (Pmode,
 747                         plus_constant (tem, GET_MODE_SIZE (Pmode)));
 748   tem = gen_frame_mem (Pmode, tem);
 749 #endif
 750   return tem;
 751 }
 752
 753 /* Alias set used for setjmp buffer.  */
 754 static alias_set_type setjmp_alias_set = -1;
 755
 756 /* Construct the leading half of a __builtin_setjmp call.  Control will
 757    return to RECEIVER_LABEL.  This is also called directly by the SJLJ
 758    exception handling code.  */
 759
 760 void
 761 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 762 {
 763   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 764   rtx stack_save;
 765   rtx mem;
 766
 767   if (setjmp_alias_set == -1)
 768     setjmp_alias_set = new_alias_set ();
 769
 770   buf_addr = convert_memory_address (Pmode, buf_addr);
 771
 772   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 773
 774   /* We store the frame pointer and the address of receiver_label in
 775      the buffer and use the rest of it for the stack save area, which
 776      is machine-dependent.  */
 777
 778   mem = gen_rtx_MEM (Pmode, buf_addr);
 779   set_mem_alias_set (mem, setjmp_alias_set);
 780   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
 781
 782   mem = gen_rtx_MEM (Pmode, plus_constant (buf_addr, GET_MODE_SIZE (Pmode))),
 783   set_mem_alias_set (mem, setjmp_alias_set);
 784
 785   emit_move_insn (validize_mem (mem),
 786                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 787
 788   stack_save = gen_rtx_MEM (sa_mode,
 789                             plus_constant (buf_addr,
 790                                            2 * GET_MODE_SIZE (Pmode)));
 791   set_mem_alias_set (stack_save, setjmp_alias_set);
 792   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
 793
 794   /* If there is further processing to do, do it.  */
 795 #ifdef HAVE_builtin_setjmp_setup
 796   if (HAVE_builtin_setjmp_setup)
 797     emit_insn (gen_builtin_setjmp_setup (buf_addr));
 798 #endif
 799
 800   /* Tell optimize_save_area_alloca that extra work is going to
 801      need to go on during alloca.  */
 802   cfun->calls_setjmp = 1;
 803
 804   /* We have a nonlocal label.   */
 805   cfun->has_nonlocal_label = 1;
 806 }
 807
 808 /* Construct the trailing part of a __builtin_setjmp call.  This is
 809    also called directly by the SJLJ exception handling code.  */
 810
 811 void
 812 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
 813 {
 814   rtx chain;
 815
 816   /* Clobber the FP when we get here, so we have to make sure it's
 817      marked as used by this function.  */
 818   emit_use (hard_frame_pointer_rtx);
 819
 820   /* Mark the static chain as clobbered here so life information
 821      doesn't get messed up for it.  */
 822   chain = targetm.calls.static_chain (current_function_decl, true);
 823   if (chain && REG_P (chain))
 824     emit_clobber (chain);
 825
 826   /* Now put in the code to restore the frame pointer, and argument
 827      pointer, if needed.  */
 828 #ifdef HAVE_nonlocal_goto
 829   if (! HAVE_nonlocal_goto)
 830 #endif
 831     {
 832       emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 833       /* This might change the hard frame pointer in ways that aren't
 834          apparent to early optimization passes, so force a clobber.  */
 835       emit_clobber (hard_frame_pointer_rtx);
 836     }
 837
 838 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
 839   if (fixed_regs[ARG_POINTER_REGNUM])
 840     {
 841 #ifdef ELIMINABLE_REGS
 842       size_t i;
 843       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 844
 845       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 846         if (elim_regs[i].from == ARG_POINTER_REGNUM
 847             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 848           break;
 849
 850       if (i == ARRAY_SIZE (elim_regs))
 851 #endif
 852         {
 853           /* Now restore our arg pointer from the address at which it
 854              was saved in our stack frame.  */
 855           emit_move_insn (crtl->args.internal_arg_pointer,
 856                           copy_to_reg (get_arg_pointer_save_area ()));
 857         }
 858     }
 859 #endif
 860
 861 #ifdef HAVE_builtin_setjmp_receiver
 862   if (HAVE_builtin_setjmp_receiver)
 863     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
 864   else
 865 #endif
 866 #ifdef HAVE_nonlocal_goto_receiver
 867     if (HAVE_nonlocal_goto_receiver)
 868       emit_insn (gen_nonlocal_goto_receiver ());
 869     else
 870 #endif
 871       { /* Nothing */ }
 872
 873   /* We must not allow the code we just generated to be reordered by
 874      scheduling.  Specifically, the update of the frame pointer must
 875      happen immediately, not later.  */
 876   emit_insn (gen_blockage ());
 877 }
 878
 879 /* __builtin_longjmp is passed a pointer to an array of five words (not
 880    all will be used on all machines).  It operates similarly to the C
 881    library function of the same name, but is more efficient.  Much of
 882    the code below is copied from the handling of non-local gotos.  */
 883
 884 static void
 885 expand_builtin_longjmp (rtx buf_addr, rtx value)
 886 {
 887   rtx fp, lab, stack, insn, last;
 888   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 889
 890   /* DRAP is needed for stack realign if longjmp is expanded to current
 891      function  */
 892   if (SUPPORTS_STACK_ALIGNMENT)
 893     crtl->need_drap = true;
 894
 895   if (setjmp_alias_set == -1)
 896     setjmp_alias_set = new_alias_set ();
 897
 898   buf_addr = convert_memory_address (Pmode, buf_addr);
 899
 900   buf_addr = force_reg (Pmode, buf_addr);
 901
 902   /* We require that the user must pass a second argument of 1, because
 903      that is what builtin_setjmp will return.  */
 904   gcc_assert (value == const1_rtx);
 905
 906   last = get_last_insn ();
 907 #ifdef HAVE_builtin_longjmp
 908   if (HAVE_builtin_longjmp)
 909     emit_insn (gen_builtin_longjmp (buf_addr));
 910   else
 911 #endif
 912     {
 913       fp = gen_rtx_MEM (Pmode, buf_addr);
 914       lab = gen_rtx_MEM (Pmode, plus_constant (buf_addr,
 915                                                GET_MODE_SIZE (Pmode)));
 916
 917       stack = gen_rtx_MEM (sa_mode, plus_constant (buf_addr,
 918                                                    2 * GET_MODE_SIZE (Pmode)));
 919       set_mem_alias_set (fp, setjmp_alias_set);
 920       set_mem_alias_set (lab, setjmp_alias_set);
 921       set_mem_alias_set (stack, setjmp_alias_set);
 922
 923       /* Pick up FP, label, and SP from the block and jump.  This code is
 924          from expand_goto in stmt.c; see there for detailed comments.  */
 925 #ifdef HAVE_nonlocal_goto
 926       if (HAVE_nonlocal_goto)
 927         /* We have to pass a value to the nonlocal_goto pattern that will
 928            get copied into the static_chain pointer, but it does not matter
 929            what that value is, because builtin_setjmp does not use it.  */
 930         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
 931       else
 932 #endif
 933         {
 934           lab = copy_to_reg (lab);
 935
 936           emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 937           emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 938
 939           emit_move_insn (hard_frame_pointer_rtx, fp);
 940           emit_stack_restore (SAVE_NONLOCAL, stack, NULL_RTX);
 941
 942           emit_use (hard_frame_pointer_rtx);
 943           emit_use (stack_pointer_rtx);
 944           emit_indirect_jump (lab);
 945         }
 946     }
 947
 948   /* Search backwards and mark the jump insn as a non-local goto.
 949      Note that this precludes the use of __builtin_longjmp to a
 950      __builtin_setjmp target in the same function.  However, we've
 951      already cautioned the user that these functions are for
 952      internal exception handling use only.  */
 953   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 954     {
 955       gcc_assert (insn != last);
 956
 957       if (JUMP_P (insn))
 958         {
 959           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
 960           break;
 961         }
 962       else if (CALL_P (insn))
 963         break;
 964     }
 965 }
 966
 967 /* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
 968    and the address of the save area.  */
 969
 970 static rtx
 971 expand_builtin_nonlocal_goto (tree exp)
 972 {
 973   tree t_label, t_save_area;
 974   rtx r_label, r_save_area, r_fp, r_sp, insn;
 975
 976   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
 977     return NULL_RTX;
 978
 979   t_label = CALL_EXPR_ARG (exp, 0);
 980   t_save_area = CALL_EXPR_ARG (exp, 1);
 981
 982   r_label = expand_normal (t_label);
 983   r_label = convert_memory_address (Pmode, r_label);
 984   r_save_area = expand_normal (t_save_area);
 985   r_save_area = convert_memory_address (Pmode, r_save_area);
 986   /* Copy the address of the save location to a register just in case it was based
 987     on the frame pointer.   */
 988   r_save_area = copy_to_reg (r_save_area);
 989   r_fp = gen_rtx_MEM (Pmode, r_save_area);
 990   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
 991                       plus_constant (r_save_area, GET_MODE_SIZE (Pmode)));
 992
 993   crtl->has_nonlocal_goto = 1;
 994
 995 #ifdef HAVE_nonlocal_goto
 996   /* ??? We no longer need to pass the static chain value, afaik.  */
 997   if (HAVE_nonlocal_goto)
 998     emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
 999   else
1000 #endif
1001     {
1002       r_label = copy_to_reg (r_label);
1003
1004       emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1005       emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1006
1007       /* Restore frame pointer for containing function.
1008          This sets the actual hard register used for the frame pointer
1009          to the location of the function's incoming static chain info.
1010          The non-local goto handler will then adjust it to contain the
1011          proper value and reload the argument pointer, if needed.  */
1012       emit_move_insn (hard_frame_pointer_rtx, r_fp);
1013       emit_stack_restore (SAVE_NONLOCAL, r_sp, NULL_RTX);
1014
1015       /* USE of hard_frame_pointer_rtx added for consistency;
1016          not clear if really needed.  */
1017       emit_use (hard_frame_pointer_rtx);
1018       emit_use (stack_pointer_rtx);
1019
1020       /* If the architecture is using a GP register, we must
1021          conservatively assume that the target function makes use of it.
1022          The prologue of functions with nonlocal gotos must therefore
1023          initialize the GP register to the appropriate value, and we
1024          must then make sure that this value is live at the point
1025          of the jump.  (Note that this doesn't necessarily apply
1026          to targets with a nonlocal_goto pattern; they are free
1027          to implement it in their own way.  Note also that this is
1028          a no-op if the GP register is a global invariant.)  */
1029       if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
1030           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
1031         emit_use (pic_offset_table_rtx);
1032
1033       emit_indirect_jump (r_label);
1034     }
1035
1036   /* Search backwards to the jump insn and mark it as a
1037      non-local goto.  */
1038   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1039     {
1040       if (JUMP_P (insn))
1041         {
1042           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1043           break;
1044         }
1045       else if (CALL_P (insn))
1046         break;
1047     }
1048
1049   return const0_rtx;
1050 }
1051
1052 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1053    (not all will be used on all machines) that was passed to __builtin_setjmp.
1054    It updates the stack pointer in that block to correspond to the current
1055    stack pointer.  */
1056
1057 static void
1058 expand_builtin_update_setjmp_buf (rtx buf_addr)
1059 {
1060   enum machine_mode sa_mode = Pmode;
1061   rtx stack_save;
1062
1063
1064 #ifdef HAVE_save_stack_nonlocal
1065   if (HAVE_save_stack_nonlocal)
1066     sa_mode = insn_data[(int) CODE_FOR_save_stack_nonlocal].operand[0].mode;
1067 #endif
1068 #ifdef STACK_SAVEAREA_MODE
1069   sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1070 #endif
1071
1072   stack_save
1073     = gen_rtx_MEM (sa_mode,
1074                    memory_address
1075                    (sa_mode,
1076                     plus_constant (buf_addr, 2 * GET_MODE_SIZE (Pmode))));
1077
1078 #ifdef HAVE_setjmp
1079   if (HAVE_setjmp)
1080     emit_insn (gen_setjmp ());
1081 #endif
1082
1083   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
1084 }
1085
1086 /* Expand a call to __builtin_prefetch.  For a target that does not support
1087    data prefetch, evaluate the memory address argument in case it has side
1088    effects.  */
1089
1090 static void
1091 expand_builtin_prefetch (tree exp)
1092 {
1093   tree arg0, arg1, arg2;
1094   int nargs;
1095   rtx op0, op1, op2;
1096
1097   if (!validate_arglist (exp, POINTER_TYPE, 0))
1098     return;
1099
1100   arg0 = CALL_EXPR_ARG (exp, 0);
1101
1102   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1103      zero (read) and argument 2 (locality) defaults to 3 (high degree of
1104      locality).  */
1105   nargs = call_expr_nargs (exp);
1106   if (nargs > 1)
1107     arg1 = CALL_EXPR_ARG (exp, 1);
1108   else
1109     arg1 = integer_zero_node;
1110   if (nargs > 2)
1111     arg2 = CALL_EXPR_ARG (exp, 2);
1112   else
1113     arg2 = integer_three_node;
1114
1115   /* Argument 0 is an address.  */
1116   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1117
1118   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
1119   if (TREE_CODE (arg1) != INTEGER_CST)
1120     {
1121       error ("second argument to %<__builtin_prefetch%> must be a constant");
1122       arg1 = integer_zero_node;
1123     }
1124   op1 = expand_normal (arg1);
1125   /* Argument 1 must be either zero or one.  */
1126   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1127     {
1128       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1129                " using zero");
1130       op1 = const0_rtx;
1131     }
1132
1133   /* Argument 2 (locality) must be a compile-time constant int.  */
1134   if (TREE_CODE (arg2) != INTEGER_CST)
1135     {
1136       error ("third argument to %<__builtin_prefetch%> must be a constant");
1137       arg2 = integer_zero_node;
1138     }
1139   op2 = expand_normal (arg2);
1140   /* Argument 2 must be 0, 1, 2, or 3.  */
1141   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1142     {
1143       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1144       op2 = const0_rtx;
1145     }
1146
1147 #ifdef HAVE_prefetch
1148   if (HAVE_prefetch)
1149     {
1150       if ((! (*insn_data[(int) CODE_FOR_prefetch].operand[0].predicate)
1151              (op0,
1152               insn_data[(int) CODE_FOR_prefetch].operand[0].mode))
1153           || (GET_MODE (op0) != Pmode))
1154         {
1155           op0 = convert_memory_address (Pmode, op0);
1156           op0 = force_reg (Pmode, op0);
1157         }
1158       emit_insn (gen_prefetch (op0, op1, op2));
1159     }
1160 #endif
1161
1162   /* Don't do anything with direct references to volatile memory, but
1163      generate code to handle other side effects.  */
1164   if (!MEM_P (op0) && side_effects_p (op0))
1165     emit_insn (op0);
1166 }
1167
1168 /* Get a MEM rtx for expression EXP which is the address of an operand
1169    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1170    the maximum length of the block of memory that might be accessed or
1171    NULL if unknown.  */
1172
1173 static rtx
1174 get_memory_rtx (tree exp, tree len)
1175 {
1176   tree orig_exp = exp;
1177   rtx addr, mem;
1178   HOST_WIDE_INT off;
1179
1180   /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1181      from its expression, for expr->a.b only <variable>.a.b is recorded.  */
1182   if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1183     exp = TREE_OPERAND (exp, 0);
1184
1185   addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1186   mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1187
1188   /* Get an expression we can use to find the attributes to assign to MEM.
1189      If it is an ADDR_EXPR, use the operand.  Otherwise, dereference it if
1190      we can.  First remove any nops.  */
1191   while (CONVERT_EXPR_P (exp)
1192          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1193     exp = TREE_OPERAND (exp, 0);
1194
1195   off = 0;
1196   if (TREE_CODE (exp) == POINTER_PLUS_EXPR
1197       && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1198       && host_integerp (TREE_OPERAND (exp, 1), 0)
1199       && (off = tree_low_cst (TREE_OPERAND (exp, 1), 0)) > 0)
1200     exp = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
1201   else if (TREE_CODE (exp) == ADDR_EXPR)
1202     exp = TREE_OPERAND (exp, 0);
1203   else if (POINTER_TYPE_P (TREE_TYPE (exp)))
1204     exp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (exp)), exp);
1205   else
1206     exp = NULL;
1207
1208   /* Honor attributes derived from exp, except for the alias set
1209      (as builtin stringops may alias with anything) and the size
1210      (as stringops may access multiple array elements).  */
1211   if (exp)
1212     {
1213       set_mem_attributes (mem, exp, 0);
1214
1215       if (off)
1216         mem = adjust_automodify_address_nv (mem, BLKmode, NULL, off);
1217
1218       /* Allow the string and memory builtins to overflow from one
1219          field into another, see http://gcc.gnu.org/PR23561.
1220          Thus avoid COMPONENT_REFs in MEM_EXPR unless we know the whole
1221          memory accessed by the string or memory builtin will fit
1222          within the field.  */
1223       if (MEM_EXPR (mem) && TREE_CODE (MEM_EXPR (mem)) == COMPONENT_REF)
1224         {
1225           tree mem_expr = MEM_EXPR (mem);
1226           HOST_WIDE_INT offset = -1, length = -1;
1227           tree inner = exp;
1228
1229           while (TREE_CODE (inner) == ARRAY_REF
1230                  || CONVERT_EXPR_P (inner)
1231                  || TREE_CODE (inner) == VIEW_CONVERT_EXPR
1232                  || TREE_CODE (inner) == SAVE_EXPR)
1233             inner = TREE_OPERAND (inner, 0);
1234
1235           gcc_assert (TREE_CODE (inner) == COMPONENT_REF);
1236
1237           if (MEM_OFFSET (mem)
1238               && CONST_INT_P (MEM_OFFSET (mem)))
1239             offset = INTVAL (MEM_OFFSET (mem));
1240
1241           if (offset >= 0 && len && host_integerp (len, 0))
1242             length = tree_low_cst (len, 0);
1243
1244           while (TREE_CODE (inner) == COMPONENT_REF)
1245             {
1246               tree field = TREE_OPERAND (inner, 1);
1247               gcc_assert (TREE_CODE (mem_expr) == COMPONENT_REF);
1248               gcc_assert (field == TREE_OPERAND (mem_expr, 1));
1249
1250               /* Bitfields are generally not byte-addressable.  */
1251               gcc_assert (!DECL_BIT_FIELD (field)
1252                           || ((tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1253                                % BITS_PER_UNIT) == 0
1254                               && host_integerp (DECL_SIZE (field), 0)
1255                               && (TREE_INT_CST_LOW (DECL_SIZE (field))
1256                                   % BITS_PER_UNIT) == 0));
1257
1258               /* If we can prove that the memory starting at XEXP (mem, 0) and
1259                  ending at XEXP (mem, 0) + LENGTH will fit into this field, we
1260                  can keep the COMPONENT_REF in MEM_EXPR.  But be careful with
1261                  fields without DECL_SIZE_UNIT like flexible array members.  */
1262               if (length >= 0
1263                   && DECL_SIZE_UNIT (field)
1264                   && host_integerp (DECL_SIZE_UNIT (field), 0))
1265                 {
1266                   HOST_WIDE_INT size
1267                     = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field));
1268                   if (offset <= size
1269                       && length <= size
1270                       && offset + length <= size)
1271                     break;
1272                 }
1273
1274               if (offset >= 0
1275                   && host_integerp (DECL_FIELD_OFFSET (field), 0))
1276                 offset += TREE_INT_CST_LOW (DECL_FIELD_OFFSET (field))
1277                           + tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 1)
1278                             / BITS_PER_UNIT;
1279               else
1280                 {
1281                   offset = -1;
1282                   length = -1;
1283                 }
1284
1285               mem_expr = TREE_OPERAND (mem_expr, 0);
1286               inner = TREE_OPERAND (inner, 0);
1287             }
1288
1289           if (mem_expr == NULL)
1290             offset = -1;
1291           if (mem_expr != MEM_EXPR (mem))
1292             {
1293               set_mem_expr (mem, mem_expr);
1294               set_mem_offset (mem, offset >= 0 ? GEN_INT (offset) : NULL_RTX);
1295             }
1296         }
1297       set_mem_alias_set (mem, 0);
1298       set_mem_size (mem, NULL_RTX);
1299     }
1300
1301   return mem;
1302 }
1303 \f
1304 /* Built-in functions to perform an untyped call and return.  */
1305
1306 #define apply_args_mode \
1307   (this_target_builtins->x_apply_args_mode)
1308 #define apply_result_mode \
1309   (this_target_builtins->x_apply_result_mode)
1310
1311 /* Return the size required for the block returned by __builtin_apply_args,
1312    and initialize apply_args_mode.  */
1313
1314 static int
1315 apply_args_size (void)
1316 {
1317   static int size = -1;
1318   int align;
1319   unsigned int regno;
1320   enum machine_mode mode;
1321
1322   /* The values computed by this function never change.  */
1323   if (size < 0)
1324     {
1325       /* The first value is the incoming arg-pointer.  */
1326       size = GET_MODE_SIZE (Pmode);
1327
1328       /* The second value is the structure value address unless this is
1329          passed as an "invisible" first argument.  */
1330       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1331         size += GET_MODE_SIZE (Pmode);
1332
1333       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1334         if (FUNCTION_ARG_REGNO_P (regno))
1335           {
1336             mode = reg_raw_mode[regno];
1337
1338             gcc_assert (mode != VOIDmode);
1339
1340             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1341             if (size % align != 0)
1342               size = CEIL (size, align) * align;
1343             size += GET_MODE_SIZE (mode);
1344             apply_args_mode[regno] = mode;
1345           }
1346         else
1347           {
1348             apply_args_mode[regno] = VOIDmode;
1349           }
1350     }
1351   return size;
1352 }
1353
1354 /* Return the size required for the block returned by __builtin_apply,
1355    and initialize apply_result_mode.  */
1356
1357 static int
1358 apply_result_size (void)
1359 {
1360   static int size = -1;
1361   int align, regno;
1362   enum machine_mode mode;
1363
1364   /* The values computed by this function never change.  */
1365   if (size < 0)
1366     {
1367       size = 0;
1368
1369       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1370         if (targetm.calls.function_value_regno_p (regno))
1371           {
1372             mode = reg_raw_mode[regno];
1373
1374             gcc_assert (mode != VOIDmode);
1375
1376             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1377             if (size % align != 0)
1378               size = CEIL (size, align) * align;
1379             size += GET_MODE_SIZE (mode);
1380             apply_result_mode[regno] = mode;
1381           }
1382         else
1383           apply_result_mode[regno] = VOIDmode;
1384
1385       /* Allow targets that use untyped_call and untyped_return to override
1386          the size so that machine-specific information can be stored here.  */
1387 #ifdef APPLY_RESULT_SIZE
1388       size = APPLY_RESULT_SIZE;
1389 #endif
1390     }
1391   return size;
1392 }
1393
1394 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1395 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1396    the result block is used to save the values; otherwise it is used to
1397    restore the values.  */
1398
1399 static rtx
1400 result_vector (int savep, rtx result)
1401 {
1402   int regno, size, align, nelts;
1403   enum machine_mode mode;
1404   rtx reg, mem;
1405   rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1406
1407   size = nelts = 0;
1408   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1409     if ((mode = apply_result_mode[regno]) != VOIDmode)
1410       {
1411         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1412         if (size % align != 0)
1413           size = CEIL (size, align) * align;
1414         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1415         mem = adjust_address (result, mode, size);
1416         savevec[nelts++] = (savep
1417                             ? gen_rtx_SET (VOIDmode, mem, reg)
1418                             : gen_rtx_SET (VOIDmode, reg, mem));
1419         size += GET_MODE_SIZE (mode);
1420       }
1421   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1422 }
1423 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1424
1425 /* Save the state required to perform an untyped call with the same
1426    arguments as were passed to the current function.  */
1427
1428 static rtx
1429 expand_builtin_apply_args_1 (void)
1430 {
1431   rtx registers, tem;
1432   int size, align, regno;
1433   enum machine_mode mode;
1434   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1435
1436   /* Create a block where the arg-pointer, structure value address,
1437      and argument registers can be saved.  */
1438   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1439
1440   /* Walk past the arg-pointer and structure value address.  */
1441   size = GET_MODE_SIZE (Pmode);
1442   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1443     size += GET_MODE_SIZE (Pmode);
1444
1445   /* Save each register used in calling a function to the block.  */
1446   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1447     if ((mode = apply_args_mode[regno]) != VOIDmode)
1448       {
1449         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1450         if (size % align != 0)
1451           size = CEIL (size, align) * align;
1452
1453         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1454
1455         emit_move_insn (adjust_address (registers, mode, size), tem);
1456         size += GET_MODE_SIZE (mode);
1457       }
1458
1459   /* Save the arg pointer to the block.  */
1460   tem = copy_to_reg (crtl->args.internal_arg_pointer);
1461 #ifdef STACK_GROWS_DOWNWARD
1462   /* We need the pointer as the caller actually passed them to us, not
1463      as we might have pretended they were passed.  Make sure it's a valid
1464      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1465   tem
1466     = force_operand (plus_constant (tem, crtl->args.pretend_args_size),
1467                      NULL_RTX);
1468 #endif
1469   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1470
1471   size = GET_MODE_SIZE (Pmode);
1472
1473   /* Save the structure value address unless this is passed as an
1474      "invisible" first argument.  */
1475   if (struct_incoming_value)
1476     {
1477       emit_move_insn (adjust_address (registers, Pmode, size),
1478                       copy_to_reg (struct_incoming_value));
1479       size += GET_MODE_SIZE (Pmode);
1480     }
1481
1482   /* Return the address of the block.  */
1483   return copy_addr_to_reg (XEXP (registers, 0));
1484 }
1485
1486 /* __builtin_apply_args returns block of memory allocated on
1487    the stack into which is stored the arg pointer, structure
1488    value address, static chain, and all the registers that might
1489    possibly be used in performing a function call.  The code is
1490    moved to the start of the function so the incoming values are
1491    saved.  */
1492
1493 static rtx
1494 expand_builtin_apply_args (void)
1495 {
1496   /* Don't do __builtin_apply_args more than once in a function.
1497      Save the result of the first call and reuse it.  */
1498   if (apply_args_value != 0)
1499     return apply_args_value;
1500   {
1501     /* When this function is called, it means that registers must be
1502        saved on entry to this function.  So we migrate the
1503        call to the first insn of this function.  */
1504     rtx temp;
1505     rtx seq;
1506
1507     start_sequence ();
1508     temp = expand_builtin_apply_args_1 ();
1509     seq = get_insns ();
1510     end_sequence ();
1511
1512     apply_args_value = temp;
1513
1514     /* Put the insns after the NOTE that starts the function.
1515        If this is inside a start_sequence, make the outer-level insn
1516        chain current, so the code is placed at the start of the
1517        function.  If internal_arg_pointer is a non-virtual pseudo,
1518        it needs to be placed after the function that initializes
1519        that pseudo.  */
1520     push_topmost_sequence ();
1521     if (REG_P (crtl->args.internal_arg_pointer)
1522         && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1523       emit_insn_before (seq, parm_birth_insn);
1524     else
1525       emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1526     pop_topmost_sequence ();
1527     return temp;
1528   }
1529 }
1530
1531 /* Perform an untyped call and save the state required to perform an
1532    untyped return of whatever value was returned by the given function.  */
1533
1534 static rtx
1535 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1536 {
1537   int size, align, regno;
1538   enum machine_mode mode;
1539   rtx incoming_args, result, reg, dest, src, call_insn;
1540   rtx old_stack_level = 0;
1541   rtx call_fusage = 0;
1542   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1543
1544   arguments = convert_memory_address (Pmode, arguments);
1545
1546   /* Create a block where the return registers can be saved.  */
1547   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1548
1549   /* Fetch the arg pointer from the ARGUMENTS block.  */
1550   incoming_args = gen_reg_rtx (Pmode);
1551   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1552 #ifndef STACK_GROWS_DOWNWARD
1553   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1554                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1555 #endif
1556
1557   /* Push a new argument block and copy the arguments.  Do not allow
1558      the (potential) memcpy call below to interfere with our stack
1559      manipulations.  */
1560   do_pending_stack_adjust ();
1561   NO_DEFER_POP;
1562
1563   /* Save the stack with nonlocal if available.  */
1564 #ifdef HAVE_save_stack_nonlocal
1565   if (HAVE_save_stack_nonlocal)
1566     emit_stack_save (SAVE_NONLOCAL, &old_stack_level, NULL_RTX);
1567   else
1568 #endif
1569     emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1570
1571   /* Allocate a block of memory onto the stack and copy the memory
1572      arguments to the outgoing arguments address.  We can pass TRUE
1573      as the 4th argument because we just saved the stack pointer
1574      and will restore it right after the call.  */
1575   allocate_dynamic_stack_space (argsize, 0, BIGGEST_ALIGNMENT, true);
1576
1577   /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1578      may have already set current_function_calls_alloca to true.
1579      current_function_calls_alloca won't be set if argsize is zero,
1580      so we have to guarantee need_drap is true here.  */
1581   if (SUPPORTS_STACK_ALIGNMENT)
1582     crtl->need_drap = true;
1583
1584   dest = virtual_outgoing_args_rtx;
1585 #ifndef STACK_GROWS_DOWNWARD
1586   if (CONST_INT_P (argsize))
1587     dest = plus_constant (dest, -INTVAL (argsize));
1588   else
1589     dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1590 #endif
1591   dest = gen_rtx_MEM (BLKmode, dest);
1592   set_mem_align (dest, PARM_BOUNDARY);
1593   src = gen_rtx_MEM (BLKmode, incoming_args);
1594   set_mem_align (src, PARM_BOUNDARY);
1595   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1596
1597   /* Refer to the argument block.  */
1598   apply_args_size ();
1599   arguments = gen_rtx_MEM (BLKmode, arguments);
1600   set_mem_align (arguments, PARM_BOUNDARY);
1601
1602   /* Walk past the arg-pointer and structure value address.  */
1603   size = GET_MODE_SIZE (Pmode);
1604   if (struct_value)
1605     size += GET_MODE_SIZE (Pmode);
1606
1607   /* Restore each of the registers previously saved.  Make USE insns
1608      for each of these registers for use in making the call.  */
1609   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1610     if ((mode = apply_args_mode[regno]) != VOIDmode)
1611       {
1612         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1613         if (size % align != 0)
1614           size = CEIL (size, align) * align;
1615         reg = gen_rtx_REG (mode, regno);
1616         emit_move_insn (reg, adjust_address (arguments, mode, size));
1617         use_reg (&call_fusage, reg);
1618         size += GET_MODE_SIZE (mode);
1619       }
1620
1621   /* Restore the structure value address unless this is passed as an
1622      "invisible" first argument.  */
1623   size = GET_MODE_SIZE (Pmode);
1624   if (struct_value)
1625     {
1626       rtx value = gen_reg_rtx (Pmode);
1627       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1628       emit_move_insn (struct_value, value);
1629       if (REG_P (struct_value))
1630         use_reg (&call_fusage, struct_value);
1631       size += GET_MODE_SIZE (Pmode);
1632     }
1633
1634   /* All arguments and registers used for the call are set up by now!  */
1635   function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1636
1637   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1638      and we don't want to load it into a register as an optimization,
1639      because prepare_call_address already did it if it should be done.  */
1640   if (GET_CODE (function) != SYMBOL_REF)
1641     function = memory_address (FUNCTION_MODE, function);
1642
1643   /* Generate the actual call instruction and save the return value.  */
1644 #ifdef HAVE_untyped_call
1645   if (HAVE_untyped_call)
1646     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1647                                       result, result_vector (1, result)));
1648   else
1649 #endif
1650 #ifdef HAVE_call_value
1651   if (HAVE_call_value)
1652     {
1653       rtx valreg = 0;
1654
1655       /* Locate the unique return register.  It is not possible to
1656          express a call that sets more than one return register using
1657          call_value; use untyped_call for that.  In fact, untyped_call
1658          only needs to save the return registers in the given block.  */
1659       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1660         if ((mode = apply_result_mode[regno]) != VOIDmode)
1661           {
1662             gcc_assert (!valreg); /* HAVE_untyped_call required.  */
1663
1664             valreg = gen_rtx_REG (mode, regno);
1665           }
1666
1667       emit_call_insn (GEN_CALL_VALUE (valreg,
1668                                       gen_rtx_MEM (FUNCTION_MODE, function),
1669                                       const0_rtx, NULL_RTX, const0_rtx));
1670
1671       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1672     }
1673   else
1674 #endif
1675     gcc_unreachable ();
1676
1677   /* Find the CALL insn we just emitted, and attach the register usage
1678      information.  */
1679   call_insn = last_call_insn ();
1680   add_function_usage_to (call_insn, call_fusage);
1681
1682   /* Restore the stack.  */
1683 #ifdef HAVE_save_stack_nonlocal
1684   if (HAVE_save_stack_nonlocal)
1685     emit_stack_restore (SAVE_NONLOCAL, old_stack_level, NULL_RTX);
1686   else
1687 #endif
1688     emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1689
1690   OK_DEFER_POP;
1691
1692   /* Return the address of the result block.  */
1693   result = copy_addr_to_reg (XEXP (result, 0));
1694   return convert_memory_address (ptr_mode, result);
1695 }
1696
1697 /* Perform an untyped return.  */
1698
1699 static void
1700 expand_builtin_return (rtx result)
1701 {
1702   int size, align, regno;
1703   enum machine_mode mode;
1704   rtx reg;
1705   rtx call_fusage = 0;
1706
1707   result = convert_memory_address (Pmode, result);
1708
1709   apply_result_size ();
1710   result = gen_rtx_MEM (BLKmode, result);
1711
1712 #ifdef HAVE_untyped_return
1713   if (HAVE_untyped_return)
1714     {
1715       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1716       emit_barrier ();
1717       return;
1718     }
1719 #endif
1720
1721   /* Restore the return value and note that each value is used.  */
1722   size = 0;
1723   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1724     if ((mode = apply_result_mode[regno]) != VOIDmode)
1725       {
1726         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1727         if (size % align != 0)
1728           size = CEIL (size, align) * align;
1729         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1730         emit_move_insn (reg, adjust_address (result, mode, size));
1731
1732         push_to_sequence (call_fusage);
1733         emit_use (reg);
1734         call_fusage = get_insns ();
1735         end_sequence ();
1736         size += GET_MODE_SIZE (mode);
1737       }
1738
1739   /* Put the USE insns before the return.  */
1740   emit_insn (call_fusage);
1741
1742   /* Return whatever values was restored by jumping directly to the end
1743      of the function.  */
1744   expand_naked_return ();
1745 }
1746
1747 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1748
1749 static enum type_class
1750 type_to_class (tree type)
1751 {
1752   switch (TREE_CODE (type))
1753     {
1754     case VOID_TYPE:        return void_type_class;
1755     case INTEGER_TYPE:     return integer_type_class;
1756     case ENUMERAL_TYPE:    return enumeral_type_class;
1757     case BOOLEAN_TYPE:     return boolean_type_class;
1758     case POINTER_TYPE:     return pointer_type_class;
1759     case REFERENCE_TYPE:   return reference_type_class;
1760     case OFFSET_TYPE:      return offset_type_class;
1761     case REAL_TYPE:        return real_type_class;
1762     case COMPLEX_TYPE:     return complex_type_class;
1763     case FUNCTION_TYPE:    return function_type_class;
1764     case METHOD_TYPE:      return method_type_class;
1765     case RECORD_TYPE:      return record_type_class;
1766     case UNION_TYPE:
1767     case QUAL_UNION_TYPE:  return union_type_class;
1768     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1769                                    ? string_type_class : array_type_class);
1770     case LANG_TYPE:        return lang_type_class;
1771     default:               return no_type_class;
1772     }
1773 }
1774
1775 /* Expand a call EXP to __builtin_classify_type.  */
1776
1777 static rtx
1778 expand_builtin_classify_type (tree exp)
1779 {
1780   if (call_expr_nargs (exp))
1781     return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1782   return GEN_INT (no_type_class);
1783 }
1784
1785 /* This helper macro, meant to be used in mathfn_built_in below,
1786    determines which among a set of three builtin math functions is
1787    appropriate for a given type mode.  The `F' and `L' cases are
1788    automatically generated from the `double' case.  */
1789 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1790   case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1791   fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1792   fcodel = BUILT_IN_MATHFN##L ; break;
1793 /* Similar to above, but appends _R after any F/L suffix.  */
1794 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1795   case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1796   fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1797   fcodel = BUILT_IN_MATHFN##L_R ; break;
1798
1799 /* Return mathematic function equivalent to FN but operating directly
1800    on TYPE, if available.  If IMPLICIT is true find the function in
1801    implicit_built_in_decls[], otherwise use built_in_decls[].  If we
1802    can't do the conversion, return zero.  */
1803
1804 static tree
1805 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit)
1806 {
1807   tree const *const fn_arr
1808     = implicit ? implicit_built_in_decls : built_in_decls;
1809   enum built_in_function fcode, fcodef, fcodel;
1810
1811   switch (fn)
1812     {
1813       CASE_MATHFN (BUILT_IN_ACOS)
1814       CASE_MATHFN (BUILT_IN_ACOSH)
1815       CASE_MATHFN (BUILT_IN_ASIN)
1816       CASE_MATHFN (BUILT_IN_ASINH)
1817       CASE_MATHFN (BUILT_IN_ATAN)
1818       CASE_MATHFN (BUILT_IN_ATAN2)
1819       CASE_MATHFN (BUILT_IN_ATANH)
1820       CASE_MATHFN (BUILT_IN_CBRT)
1821       CASE_MATHFN (BUILT_IN_CEIL)
1822       CASE_MATHFN (BUILT_IN_CEXPI)
1823       CASE_MATHFN (BUILT_IN_COPYSIGN)
1824       CASE_MATHFN (BUILT_IN_COS)
1825       CASE_MATHFN (BUILT_IN_COSH)
1826       CASE_MATHFN (BUILT_IN_DREM)
1827       CASE_MATHFN (BUILT_IN_ERF)
1828       CASE_MATHFN (BUILT_IN_ERFC)
1829       CASE_MATHFN (BUILT_IN_EXP)
1830       CASE_MATHFN (BUILT_IN_EXP10)
1831       CASE_MATHFN (BUILT_IN_EXP2)
1832       CASE_MATHFN (BUILT_IN_EXPM1)
1833       CASE_MATHFN (BUILT_IN_FABS)
1834       CASE_MATHFN (BUILT_IN_FDIM)
1835       CASE_MATHFN (BUILT_IN_FLOOR)
1836       CASE_MATHFN (BUILT_IN_FMA)
1837       CASE_MATHFN (BUILT_IN_FMAX)
1838       CASE_MATHFN (BUILT_IN_FMIN)
1839       CASE_MATHFN (BUILT_IN_FMOD)
1840       CASE_MATHFN (BUILT_IN_FREXP)
1841       CASE_MATHFN (BUILT_IN_GAMMA)
1842       CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1843       CASE_MATHFN (BUILT_IN_HUGE_VAL)
1844       CASE_MATHFN (BUILT_IN_HYPOT)
1845       CASE_MATHFN (BUILT_IN_ILOGB)
1846       CASE_MATHFN (BUILT_IN_INF)
1847       CASE_MATHFN (BUILT_IN_ISINF)
1848       CASE_MATHFN (BUILT_IN_J0)
1849       CASE_MATHFN (BUILT_IN_J1)
1850       CASE_MATHFN (BUILT_IN_JN)
1851       CASE_MATHFN (BUILT_IN_LCEIL)
1852       CASE_MATHFN (BUILT_IN_LDEXP)
1853       CASE_MATHFN (BUILT_IN_LFLOOR)
1854       CASE_MATHFN (BUILT_IN_LGAMMA)
1855       CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1856       CASE_MATHFN (BUILT_IN_LLCEIL)
1857       CASE_MATHFN (BUILT_IN_LLFLOOR)
1858       CASE_MATHFN (BUILT_IN_LLRINT)
1859       CASE_MATHFN (BUILT_IN_LLROUND)
1860       CASE_MATHFN (BUILT_IN_LOG)
1861       CASE_MATHFN (BUILT_IN_LOG10)
1862       CASE_MATHFN (BUILT_IN_LOG1P)
1863       CASE_MATHFN (BUILT_IN_LOG2)
1864       CASE_MATHFN (BUILT_IN_LOGB)
1865       CASE_MATHFN (BUILT_IN_LRINT)
1866       CASE_MATHFN (BUILT_IN_LROUND)
1867       CASE_MATHFN (BUILT_IN_MODF)
1868       CASE_MATHFN (BUILT_IN_NAN)
1869       CASE_MATHFN (BUILT_IN_NANS)
1870       CASE_MATHFN (BUILT_IN_NEARBYINT)
1871       CASE_MATHFN (BUILT_IN_NEXTAFTER)
1872       CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1873       CASE_MATHFN (BUILT_IN_POW)
1874       CASE_MATHFN (BUILT_IN_POWI)
1875       CASE_MATHFN (BUILT_IN_POW10)
1876       CASE_MATHFN (BUILT_IN_REMAINDER)
1877       CASE_MATHFN (BUILT_IN_REMQUO)
1878       CASE_MATHFN (BUILT_IN_RINT)
1879       CASE_MATHFN (BUILT_IN_ROUND)
1880       CASE_MATHFN (BUILT_IN_SCALB)
1881       CASE_MATHFN (BUILT_IN_SCALBLN)
1882       CASE_MATHFN (BUILT_IN_SCALBN)
1883       CASE_MATHFN (BUILT_IN_SIGNBIT)
1884       CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1885       CASE_MATHFN (BUILT_IN_SIN)
1886       CASE_MATHFN (BUILT_IN_SINCOS)
1887       CASE_MATHFN (BUILT_IN_SINH)
1888       CASE_MATHFN (BUILT_IN_SQRT)
1889       CASE_MATHFN (BUILT_IN_TAN)
1890       CASE_MATHFN (BUILT_IN_TANH)
1891       CASE_MATHFN (BUILT_IN_TGAMMA)
1892       CASE_MATHFN (BUILT_IN_TRUNC)
1893       CASE_MATHFN (BUILT_IN_Y0)
1894       CASE_MATHFN (BUILT_IN_Y1)
1895       CASE_MATHFN (BUILT_IN_YN)
1896
1897       default:
1898         return NULL_TREE;
1899       }
1900
1901   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1902     return fn_arr[fcode];
1903   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1904     return fn_arr[fcodef];
1905   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1906     return fn_arr[fcodel];
1907   else
1908     return NULL_TREE;
1909 }
1910
1911 /* Like mathfn_built_in_1(), but always use the implicit array.  */
1912
1913 tree
1914 mathfn_built_in (tree type, enum built_in_function fn)
1915 {
1916   return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1917 }
1918
1919 /* If errno must be maintained, expand the RTL to check if the result,
1920    TARGET, of a built-in function call, EXP, is NaN, and if so set
1921    errno to EDOM.  */
1922
1923 static void
1924 expand_errno_check (tree exp, rtx target)
1925 {
1926   rtx lab = gen_label_rtx ();
1927
1928   /* Test the result; if it is NaN, set errno=EDOM because
1929      the argument was not in the domain.  */
1930   do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1931                            NULL_RTX, NULL_RTX, lab,
1932                            /* The jump is very likely.  */
1933                            REG_BR_PROB_BASE - (REG_BR_PROB_BASE / 2000 - 1));
1934
1935 #ifdef TARGET_EDOM
1936   /* If this built-in doesn't throw an exception, set errno directly.  */
1937   if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1938     {
1939 #ifdef GEN_ERRNO_RTX
1940       rtx errno_rtx = GEN_ERRNO_RTX;
1941 #else
1942       rtx errno_rtx
1943           = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1944 #endif
1945       emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1946       emit_label (lab);
1947       return;
1948     }
1949 #endif
1950
1951   /* Make sure the library call isn't expanded as a tail call.  */
1952   CALL_EXPR_TAILCALL (exp) = 0;
1953
1954   /* We can't set errno=EDOM directly; let the library call do it.
1955      Pop the arguments right away in case the call gets deleted.  */
1956   NO_DEFER_POP;
1957   expand_call (exp, target, 0);
1958   OK_DEFER_POP;
1959   emit_label (lab);
1960 }
1961
1962 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1963    Return NULL_RTX if a normal call should be emitted rather than expanding
1964    the function in-line.  EXP is the expression that is a call to the builtin
1965    function; if convenient, the result should be placed in TARGET.
1966    SUBTARGET may be used as the target for computing one of EXP's operands.  */
1967
1968 static rtx
1969 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1970 {
1971   optab builtin_optab;
1972   rtx op0, insns;
1973   tree fndecl = get_callee_fndecl (exp);
1974   enum machine_mode mode;
1975   bool errno_set = false;
1976   tree arg;
1977
1978   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1979     return NULL_RTX;
1980
1981   arg = CALL_EXPR_ARG (exp, 0);
1982
1983   switch (DECL_FUNCTION_CODE (fndecl))
1984     {
1985     CASE_FLT_FN (BUILT_IN_SQRT):
1986       errno_set = ! tree_expr_nonnegative_p (arg);
1987       builtin_optab = sqrt_optab;
1988       break;
1989     CASE_FLT_FN (BUILT_IN_EXP):
1990       errno_set = true; builtin_optab = exp_optab; break;
1991     CASE_FLT_FN (BUILT_IN_EXP10):
1992     CASE_FLT_FN (BUILT_IN_POW10):
1993       errno_set = true; builtin_optab = exp10_optab; break;
1994     CASE_FLT_FN (BUILT_IN_EXP2):
1995       errno_set = true; builtin_optab = exp2_optab; break;
1996     CASE_FLT_FN (BUILT_IN_EXPM1):
1997       errno_set = true; builtin_optab = expm1_optab; break;
1998     CASE_FLT_FN (BUILT_IN_LOGB):
1999       errno_set = true; builtin_optab = logb_optab; break;
2000     CASE_FLT_FN (BUILT_IN_LOG):
2001       errno_set = true; builtin_optab = log_optab; break;
2002     CASE_FLT_FN (BUILT_IN_LOG10):
2003       errno_set = true; builtin_optab = log10_optab; break;
2004     CASE_FLT_FN (BUILT_IN_LOG2):
2005       errno_set = true; builtin_optab = log2_optab; break;
2006     CASE_FLT_FN (BUILT_IN_LOG1P):
2007       errno_set = true; builtin_optab = log1p_optab; break;
2008     CASE_FLT_FN (BUILT_IN_ASIN):
2009       builtin_optab = asin_optab; break;
2010     CASE_FLT_FN (BUILT_IN_ACOS):
2011       builtin_optab = acos_optab; break;
2012     CASE_FLT_FN (BUILT_IN_TAN):
2013       builtin_optab = tan_optab; break;
2014     CASE_FLT_FN (BUILT_IN_ATAN):
2015       builtin_optab = atan_optab; break;
2016     CASE_FLT_FN (BUILT_IN_FLOOR):
2017       builtin_optab = floor_optab; break;
2018     CASE_FLT_FN (BUILT_IN_CEIL):
2019       builtin_optab = ceil_optab; break;
2020     CASE_FLT_FN (BUILT_IN_TRUNC):
2021       builtin_optab = btrunc_optab; break;
2022     CASE_FLT_FN (BUILT_IN_ROUND):
2023       builtin_optab = round_optab; break;
2024     CASE_FLT_FN (BUILT_IN_NEARBYINT):
2025       builtin_optab = nearbyint_optab;
2026       if (flag_trapping_math)
2027         break;
2028       /* Else fallthrough and expand as rint.  */
2029     CASE_FLT_FN (BUILT_IN_RINT):
2030       builtin_optab = rint_optab; break;
2031     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
2032       builtin_optab = significand_optab; break;
2033     default:
2034       gcc_unreachable ();
2035     }
2036
2037   /* Make a suitable register to place result in.  */
2038   mode = TYPE_MODE (TREE_TYPE (exp));
2039
2040   if (! flag_errno_math || ! HONOR_NANS (mode))
2041     errno_set = false;
2042
2043   /* Before working hard, check whether the instruction is available.  */
2044   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2045     {
2046       target = gen_reg_rtx (mode);
2047
2048       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2049          need to expand the argument again.  This way, we will not perform
2050          side-effects more the once.  */
2051       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2052
2053       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2054
2055       start_sequence ();
2056
2057       /* Compute into TARGET.
2058          Set TARGET to wherever the result comes back.  */
2059       target = expand_unop (mode, builtin_optab, op0, target, 0);
2060
2061       if (target != 0)
2062         {
2063           if (errno_set)
2064             expand_errno_check (exp, target);
2065
2066           /* Output the entire sequence.  */
2067           insns = get_insns ();
2068           end_sequence ();
2069           emit_insn (insns);
2070           return target;
2071         }
2072
2073       /* If we were unable to expand via the builtin, stop the sequence
2074          (without outputting the insns) and call to the library function
2075          with the stabilized argument list.  */
2076       end_sequence ();
2077     }
2078
2079   return expand_call (exp, target, target == const0_rtx);
2080 }
2081
2082 /* Expand a call to the builtin binary math functions (pow and atan2).
2083    Return NULL_RTX if a normal call should be emitted rather than expanding the
2084    function in-line.  EXP is the expression that is a call to the builtin
2085    function; if convenient, the result should be placed in TARGET.
2086    SUBTARGET may be used as the target for computing one of EXP's
2087    operands.  */
2088
2089 static rtx
2090 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2091 {
2092   optab builtin_optab;
2093   rtx op0, op1, insns;
2094   int op1_type = REAL_TYPE;
2095   tree fndecl = get_callee_fndecl (exp);
2096   tree arg0, arg1;
2097   enum machine_mode mode;
2098   bool errno_set = true;
2099
2100   switch (DECL_FUNCTION_CODE (fndecl))
2101     {
2102     CASE_FLT_FN (BUILT_IN_SCALBN):
2103     CASE_FLT_FN (BUILT_IN_SCALBLN):
2104     CASE_FLT_FN (BUILT_IN_LDEXP):
2105       op1_type = INTEGER_TYPE;
2106     default:
2107       break;
2108     }
2109
2110   if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2111     return NULL_RTX;
2112
2113   arg0 = CALL_EXPR_ARG (exp, 0);
2114   arg1 = CALL_EXPR_ARG (exp, 1);
2115
2116   switch (DECL_FUNCTION_CODE (fndecl))
2117     {
2118     CASE_FLT_FN (BUILT_IN_POW):
2119       builtin_optab = pow_optab; break;
2120     CASE_FLT_FN (BUILT_IN_ATAN2):
2121       builtin_optab = atan2_optab; break;
2122     CASE_FLT_FN (BUILT_IN_SCALB):
2123       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2124         return 0;
2125       builtin_optab = scalb_optab; break;
2126     CASE_FLT_FN (BUILT_IN_SCALBN):
2127     CASE_FLT_FN (BUILT_IN_SCALBLN):
2128       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2129         return 0;
2130     /* Fall through... */
2131     CASE_FLT_FN (BUILT_IN_LDEXP):
2132       builtin_optab = ldexp_optab; break;
2133     CASE_FLT_FN (BUILT_IN_FMOD):
2134       builtin_optab = fmod_optab; break;
2135     CASE_FLT_FN (BUILT_IN_REMAINDER):
2136     CASE_FLT_FN (BUILT_IN_DREM):
2137       builtin_optab = remainder_optab; break;
2138     default:
2139       gcc_unreachable ();
2140     }
2141
2142   /* Make a suitable register to place result in.  */
2143   mode = TYPE_MODE (TREE_TYPE (exp));
2144
2145   /* Before working hard, check whether the instruction is available.  */
2146   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2147     return NULL_RTX;
2148
2149   target = gen_reg_rtx (mode);
2150
2151   if (! flag_errno_math || ! HONOR_NANS (mode))
2152     errno_set = false;
2153
2154   /* Always stabilize the argument list.  */
2155   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2156   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2157
2158   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2159   op1 = expand_normal (arg1);
2160
2161   start_sequence ();
2162
2163   /* Compute into TARGET.
2164      Set TARGET to wherever the result comes back.  */
2165   target = expand_binop (mode, builtin_optab, op0, op1,
2166                          target, 0, OPTAB_DIRECT);
2167
2168   /* If we were unable to expand via the builtin, stop the sequence
2169      (without outputting the insns) and call to the library function
2170      with the stabilized argument list.  */
2171   if (target == 0)
2172     {
2173       end_sequence ();
2174       return expand_call (exp, target, target == const0_rtx);
2175     }
2176
2177   if (errno_set)
2178     expand_errno_check (exp, target);
2179
2180   /* Output the entire sequence.  */
2181   insns = get_insns ();
2182   end_sequence ();
2183   emit_insn (insns);
2184
2185   return target;
2186 }
2187
2188 /* Expand a call to the builtin sin and cos math functions.
2189    Return NULL_RTX if a normal call should be emitted rather than expanding the
2190    function in-line.  EXP is the expression that is a call to the builtin
2191    function; if convenient, the result should be placed in TARGET.
2192    SUBTARGET may be used as the target for computing one of EXP's
2193    operands.  */
2194
2195 static rtx
2196 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2197 {
2198   optab builtin_optab;
2199   rtx op0, insns;
2200   tree fndecl = get_callee_fndecl (exp);
2201   enum machine_mode mode;
2202   tree arg;
2203
2204   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2205     return NULL_RTX;
2206
2207   arg = CALL_EXPR_ARG (exp, 0);
2208
2209   switch (DECL_FUNCTION_CODE (fndecl))
2210     {
2211     CASE_FLT_FN (BUILT_IN_SIN):
2212     CASE_FLT_FN (BUILT_IN_COS):
2213       builtin_optab = sincos_optab; break;
2214     default:
2215       gcc_unreachable ();
2216     }
2217
2218   /* Make a suitable register to place result in.  */
2219   mode = TYPE_MODE (TREE_TYPE (exp));
2220
2221   /* Check if sincos insn is available, otherwise fallback
2222      to sin or cos insn.  */
2223   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2224     switch (DECL_FUNCTION_CODE (fndecl))
2225       {
2226       CASE_FLT_FN (BUILT_IN_SIN):
2227         builtin_optab = sin_optab; break;
2228       CASE_FLT_FN (BUILT_IN_COS):
2229         builtin_optab = cos_optab; break;
2230       default:
2231         gcc_unreachable ();
2232       }
2233
2234   /* Before working hard, check whether the instruction is available.  */
2235   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2236     {
2237       target = gen_reg_rtx (mode);
2238
2239       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2240          need to expand the argument again.  This way, we will not perform
2241          side-effects more the once.  */
2242       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2243
2244       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2245
2246       start_sequence ();
2247
2248       /* Compute into TARGET.
2249          Set TARGET to wherever the result comes back.  */
2250       if (builtin_optab == sincos_optab)
2251         {
2252           int result;
2253
2254           switch (DECL_FUNCTION_CODE (fndecl))
2255             {
2256             CASE_FLT_FN (BUILT_IN_SIN):
2257               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2258               break;
2259             CASE_FLT_FN (BUILT_IN_COS):
2260               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2261               break;
2262             default:
2263               gcc_unreachable ();
2264             }
2265           gcc_assert (result);
2266         }
2267       else
2268         {
2269           target = expand_unop (mode, builtin_optab, op0, target, 0);
2270         }
2271
2272       if (target != 0)
2273         {
2274           /* Output the entire sequence.  */
2275           insns = get_insns ();
2276           end_sequence ();
2277           emit_insn (insns);
2278           return target;
2279         }
2280
2281       /* If we were unable to expand via the builtin, stop the sequence
2282          (without outputting the insns) and call to the library function
2283          with the stabilized argument list.  */
2284       end_sequence ();
2285     }
2286
2287   target = expand_call (exp, target, target == const0_rtx);
2288
2289   return target;
2290 }
2291
2292 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2293    return an RTL instruction code that implements the functionality.
2294    If that isn't possible or available return CODE_FOR_nothing.  */
2295
2296 static enum insn_code
2297 interclass_mathfn_icode (tree arg, tree fndecl)
2298 {
2299   bool errno_set = false;
2300   optab builtin_optab = 0;
2301   enum machine_mode mode;
2302
2303   switch (DECL_FUNCTION_CODE (fndecl))
2304     {
2305     CASE_FLT_FN (BUILT_IN_ILOGB):
2306       errno_set = true; builtin_optab = ilogb_optab; break;
2307     CASE_FLT_FN (BUILT_IN_ISINF):
2308       builtin_optab = isinf_optab; break;
2309     case BUILT_IN_ISNORMAL:
2310     case BUILT_IN_ISFINITE:
2311     CASE_FLT_FN (BUILT_IN_FINITE):
2312     case BUILT_IN_FINITED32:
2313     case BUILT_IN_FINITED64:
2314     case BUILT_IN_FINITED128:
2315     case BUILT_IN_ISINFD32:
2316     case BUILT_IN_ISINFD64:
2317     case BUILT_IN_ISINFD128:
2318       /* These builtins have no optabs (yet).  */
2319       break;
2320     default:
2321       gcc_unreachable ();
2322     }
2323
2324   /* There's no easy way to detect the case we need to set EDOM.  */
2325   if (flag_errno_math && errno_set)
2326     return CODE_FOR_nothing;
2327
2328   /* Optab mode depends on the mode of the input argument.  */
2329   mode = TYPE_MODE (TREE_TYPE (arg));
2330
2331   if (builtin_optab)
2332     return optab_handler (builtin_optab, mode);
2333   return CODE_FOR_nothing;
2334 }
2335
2336 /* Expand a call to one of the builtin math functions that operate on
2337    floating point argument and output an integer result (ilogb, isinf,
2338    isnan, etc).
2339    Return 0 if a normal call should be emitted rather than expanding the
2340    function in-line.  EXP is the expression that is a call to the builtin
2341    function; if convenient, the result should be placed in TARGET.  */
2342
2343 static rtx
2344 expand_builtin_interclass_mathfn (tree exp, rtx target)
2345 {
2346   enum insn_code icode = CODE_FOR_nothing;
2347   rtx op0;
2348   tree fndecl = get_callee_fndecl (exp);
2349   enum machine_mode mode;
2350   tree arg;
2351
2352   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2353     return NULL_RTX;
2354
2355   arg = CALL_EXPR_ARG (exp, 0);
2356   icode = interclass_mathfn_icode (arg, fndecl);
2357   mode = TYPE_MODE (TREE_TYPE (arg));
2358
2359   if (icode != CODE_FOR_nothing)
2360     {
2361       rtx last = get_last_insn ();
2362       tree orig_arg = arg;
2363       /* Make a suitable register to place result in.  */
2364       if (!target
2365           || GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp))
2366           || !insn_data[icode].operand[0].predicate (target, GET_MODE (target)))
2367          target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2368
2369       gcc_assert (insn_data[icode].operand[0].predicate
2370                   (target, GET_MODE (target)));
2371
2372       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2373          need to expand the argument again.  This way, we will not perform
2374          side-effects more the once.  */
2375       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2376
2377       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2378
2379       if (mode != GET_MODE (op0))
2380         op0 = convert_to_mode (mode, op0, 0);
2381
2382       /* Compute into TARGET.
2383          Set TARGET to wherever the result comes back.  */
2384       if (maybe_emit_unop_insn (icode, target, op0, UNKNOWN))
2385         return target;
2386       delete_insns_since (last);
2387       CALL_EXPR_ARG (exp, 0) = orig_arg;
2388     }
2389
2390   return NULL_RTX;
2391 }
2392
2393 /* Expand a call to the builtin sincos math function.
2394    Return NULL_RTX if a normal call should be emitted rather than expanding the
2395    function in-line.  EXP is the expression that is a call to the builtin
2396    function.  */
2397
2398 static rtx
2399 expand_builtin_sincos (tree exp)
2400 {
2401   rtx op0, op1, op2, target1, target2;
2402   enum machine_mode mode;
2403   tree arg, sinp, cosp;
2404   int result;
2405   location_t loc = EXPR_LOCATION (exp);
2406
2407   if (!validate_arglist (exp, REAL_TYPE,
2408                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2409     return NULL_RTX;
2410
2411   arg = CALL_EXPR_ARG (exp, 0);
2412   sinp = CALL_EXPR_ARG (exp, 1);
2413   cosp = CALL_EXPR_ARG (exp, 2);
2414
2415   /* Make a suitable register to place result in.  */
2416   mode = TYPE_MODE (TREE_TYPE (arg));
2417
2418   /* Check if sincos insn is available, otherwise emit the call.  */
2419   if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2420     return NULL_RTX;
2421
2422   target1 = gen_reg_rtx (mode);
2423   target2 = gen_reg_rtx (mode);
2424
2425   op0 = expand_normal (arg);
2426   op1 = expand_normal (build_fold_indirect_ref_loc (loc, sinp));
2427   op2 = expand_normal (build_fold_indirect_ref_loc (loc, cosp));
2428
2429   /* Compute into target1 and target2.
2430      Set TARGET to wherever the result comes back.  */
2431   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2432   gcc_assert (result);
2433
2434   /* Move target1 and target2 to the memory locations indicated
2435      by op1 and op2.  */
2436   emit_move_insn (op1, target1);
2437   emit_move_insn (op2, target2);
2438
2439   return const0_rtx;
2440 }
2441
2442 /* Expand a call to the internal cexpi builtin to the sincos math function.
2443    EXP is the expression that is a call to the builtin function; if convenient,
2444    the result should be placed in TARGET.  */
2445
2446 static rtx
2447 expand_builtin_cexpi (tree exp, rtx target)
2448 {
2449   tree fndecl = get_callee_fndecl (exp);
2450   tree arg, type;
2451   enum machine_mode mode;
2452   rtx op0, op1, op2;
2453   location_t loc = EXPR_LOCATION (exp);
2454
2455   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2456     return NULL_RTX;
2457
2458   arg = CALL_EXPR_ARG (exp, 0);
2459   type = TREE_TYPE (arg);
2460   mode = TYPE_MODE (TREE_TYPE (arg));
2461
2462   /* Try expanding via a sincos optab, fall back to emitting a libcall
2463      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2464      is only generated from sincos, cexp or if we have either of them.  */
2465   if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2466     {
2467       op1 = gen_reg_rtx (mode);
2468       op2 = gen_reg_rtx (mode);
2469
2470       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2471
2472       /* Compute into op1 and op2.  */
2473       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2474     }
2475   else if (TARGET_HAS_SINCOS)
2476     {
2477       tree call, fn = NULL_TREE;
2478       tree top1, top2;
2479       rtx op1a, op2a;
2480
2481       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2482         fn = built_in_decls[BUILT_IN_SINCOSF];
2483       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2484         fn = built_in_decls[BUILT_IN_SINCOS];
2485       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2486         fn = built_in_decls[BUILT_IN_SINCOSL];
2487       else
2488         gcc_unreachable ();
2489
2490       op1 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2491       op2 = assign_temp (TREE_TYPE (arg), 0, 1, 1);
2492       op1a = copy_to_mode_reg (Pmode, XEXP (op1, 0));
2493       op2a = copy_to_mode_reg (Pmode, XEXP (op2, 0));
2494       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2495       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2496
2497       /* Make sure not to fold the sincos call again.  */
2498       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2499       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2500                                       call, 3, arg, top1, top2));
2501     }
2502   else
2503     {
2504       tree call, fn = NULL_TREE, narg;
2505       tree ctype = build_complex_type (type);
2506
2507       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2508         fn = built_in_decls[BUILT_IN_CEXPF];
2509       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2510         fn = built_in_decls[BUILT_IN_CEXP];
2511       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2512         fn = built_in_decls[BUILT_IN_CEXPL];
2513       else
2514         gcc_unreachable ();
2515
2516       /* If we don't have a decl for cexp create one.  This is the
2517          friendliest fallback if the user calls __builtin_cexpi
2518          without full target C99 function support.  */
2519       if (fn == NULL_TREE)
2520         {
2521           tree fntype;
2522           const char *name = NULL;
2523
2524           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2525             name = "cexpf";
2526           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2527             name = "cexp";
2528           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2529             name = "cexpl";
2530
2531           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2532           fn = build_fn_decl (name, fntype);
2533         }
2534
2535       narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2536                           build_real (type, dconst0), arg);
2537
2538       /* Make sure not to fold the cexp call again.  */
2539       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2540       return expand_expr (build_call_nary (ctype, call, 1, narg),
2541                           target, VOIDmode, EXPAND_NORMAL);
2542     }
2543
2544   /* Now build the proper return type.  */
2545   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2546                               make_tree (TREE_TYPE (arg), op2),
2547                               make_tree (TREE_TYPE (arg), op1)),
2548                       target, VOIDmode, EXPAND_NORMAL);
2549 }
2550
2551 /* Conveniently construct a function call expression.  FNDECL names the
2552    function to be called, N is the number of arguments, and the "..."
2553    parameters are the argument expressions.  Unlike build_call_exr
2554    this doesn't fold the call, hence it will always return a CALL_EXPR.  */
2555
2556 static tree
2557 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2558 {
2559   va_list ap;
2560   tree fntype = TREE_TYPE (fndecl);
2561   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2562
2563   va_start (ap, n);
2564   fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2565   va_end (ap);
2566   SET_EXPR_LOCATION (fn, loc);
2567   return fn;
2568 }
2569
2570 /* Expand a call to one of the builtin rounding functions gcc defines
2571    as an extension (lfloor and lceil).  As these are gcc extensions we
2572    do not need to worry about setting errno to EDOM.
2573    If expanding via optab fails, lower expression to (int)(floor(x)).
2574    EXP is the expression that is a call to the builtin function;
2575    if convenient, the result should be placed in TARGET.  */
2576
2577 static rtx
2578 expand_builtin_int_roundingfn (tree exp, rtx target)
2579 {
2580   convert_optab builtin_optab;
2581   rtx op0, insns, tmp;
2582   tree fndecl = get_callee_fndecl (exp);
2583   enum built_in_function fallback_fn;
2584   tree fallback_fndecl;
2585   enum machine_mode mode;
2586   tree arg;
2587
2588   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2589     gcc_unreachable ();
2590
2591   arg = CALL_EXPR_ARG (exp, 0);
2592
2593   switch (DECL_FUNCTION_CODE (fndecl))
2594     {
2595     CASE_FLT_FN (BUILT_IN_LCEIL):
2596     CASE_FLT_FN (BUILT_IN_LLCEIL):
2597       builtin_optab = lceil_optab;
2598       fallback_fn = BUILT_IN_CEIL;
2599       break;
2600
2601     CASE_FLT_FN (BUILT_IN_LFLOOR):
2602     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2603       builtin_optab = lfloor_optab;
2604       fallback_fn = BUILT_IN_FLOOR;
2605       break;
2606
2607     default:
2608       gcc_unreachable ();
2609     }
2610
2611   /* Make a suitable register to place result in.  */
2612   mode = TYPE_MODE (TREE_TYPE (exp));
2613
2614   target = gen_reg_rtx (mode);
2615
2616   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2617      need to expand the argument again.  This way, we will not perform
2618      side-effects more the once.  */
2619   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2620
2621   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2622
2623   start_sequence ();
2624
2625   /* Compute into TARGET.  */
2626   if (expand_sfix_optab (target, op0, builtin_optab))
2627     {
2628       /* Output the entire sequence.  */
2629       insns = get_insns ();
2630       end_sequence ();
2631       emit_insn (insns);
2632       return target;
2633     }
2634
2635   /* If we were unable to expand via the builtin, stop the sequence
2636      (without outputting the insns).  */
2637   end_sequence ();
2638
2639   /* Fall back to floating point rounding optab.  */
2640   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2641
2642   /* For non-C99 targets we may end up without a fallback fndecl here
2643      if the user called __builtin_lfloor directly.  In this case emit
2644      a call to the floor/ceil variants nevertheless.  This should result
2645      in the best user experience for not full C99 targets.  */
2646   if (fallback_fndecl == NULL_TREE)
2647     {
2648       tree fntype;
2649       const char *name = NULL;
2650
2651       switch (DECL_FUNCTION_CODE (fndecl))
2652         {
2653         case BUILT_IN_LCEIL:
2654         case BUILT_IN_LLCEIL:
2655           name = "ceil";
2656           break;
2657         case BUILT_IN_LCEILF:
2658         case BUILT_IN_LLCEILF:
2659           name = "ceilf";
2660           break;
2661         case BUILT_IN_LCEILL:
2662         case BUILT_IN_LLCEILL:
2663           name = "ceill";
2664           break;
2665         case BUILT_IN_LFLOOR:
2666         case BUILT_IN_LLFLOOR:
2667           name = "floor";
2668           break;
2669         case BUILT_IN_LFLOORF:
2670         case BUILT_IN_LLFLOORF:
2671           name = "floorf";
2672           break;
2673         case BUILT_IN_LFLOORL:
2674         case BUILT_IN_LLFLOORL:
2675           name = "floorl";
2676           break;
2677         default:
2678           gcc_unreachable ();
2679         }
2680
2681       fntype = build_function_type_list (TREE_TYPE (arg),
2682                                          TREE_TYPE (arg), NULL_TREE);
2683       fallback_fndecl = build_fn_decl (name, fntype);
2684     }
2685
2686   exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2687
2688   tmp = expand_normal (exp);
2689
2690   /* Truncate the result of floating point optab to integer
2691      via expand_fix ().  */
2692   target = gen_reg_rtx (mode);
2693   expand_fix (target, tmp, 0);
2694
2695   return target;
2696 }
2697
2698 /* Expand a call to one of the builtin math functions doing integer
2699    conversion (lrint).
2700    Return 0 if a normal call should be emitted rather than expanding the
2701    function in-line.  EXP is the expression that is a call to the builtin
2702    function; if convenient, the result should be placed in TARGET.  */
2703
2704 static rtx
2705 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2706 {
2707   convert_optab builtin_optab;
2708   rtx op0, insns;
2709   tree fndecl = get_callee_fndecl (exp);
2710   tree arg;
2711   enum machine_mode mode;
2712
2713   /* There's no easy way to detect the case we need to set EDOM.  */
2714   if (flag_errno_math)
2715     return NULL_RTX;
2716
2717   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2718      gcc_unreachable ();
2719
2720   arg = CALL_EXPR_ARG (exp, 0);
2721
2722   switch (DECL_FUNCTION_CODE (fndecl))
2723     {
2724     CASE_FLT_FN (BUILT_IN_LRINT):
2725     CASE_FLT_FN (BUILT_IN_LLRINT):
2726       builtin_optab = lrint_optab; break;
2727     CASE_FLT_FN (BUILT_IN_LROUND):
2728     CASE_FLT_FN (BUILT_IN_LLROUND):
2729       builtin_optab = lround_optab; break;
2730     default:
2731       gcc_unreachable ();
2732     }
2733
2734   /* Make a suitable register to place result in.  */
2735   mode = TYPE_MODE (TREE_TYPE (exp));
2736
2737   target = gen_reg_rtx (mode);
2738
2739   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2740      need to expand the argument again.  This way, we will not perform
2741      side-effects more the once.  */
2742   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2743
2744   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2745
2746   start_sequence ();
2747
2748   if (expand_sfix_optab (target, op0, builtin_optab))
2749     {
2750       /* Output the entire sequence.  */
2751       insns = get_insns ();
2752       end_sequence ();
2753       emit_insn (insns);
2754       return target;
2755     }
2756
2757   /* If we were unable to expand via the builtin, stop the sequence
2758      (without outputting the insns) and call to the library function
2759      with the stabilized argument list.  */
2760   end_sequence ();
2761
2762   target = expand_call (exp, target, target == const0_rtx);
2763
2764   return target;
2765 }
2766
2767 /* To evaluate powi(x,n), the floating point value x raised to the
2768    constant integer exponent n, we use a hybrid algorithm that
2769    combines the "window method" with look-up tables.  For an
2770    introduction to exponentiation algorithms and "addition chains",
2771    see section 4.6.3, "Evaluation of Powers" of Donald E. Knuth,
2772    "Seminumerical Algorithms", Vol. 2, "The Art of Computer Programming",
2773    3rd Edition, 1998, and Daniel M. Gordon, "A Survey of Fast Exponentiation
2774    Methods", Journal of Algorithms, Vol. 27, pp. 129-146, 1998.  */
2775
2776 /* Provide a default value for POWI_MAX_MULTS, the maximum number of
2777    multiplications to inline before calling the system library's pow
2778    function.  powi(x,n) requires at worst 2*bits(n)-2 multiplications,
2779    so this default never requires calling pow, powf or powl.  */
2780
2781 #ifndef POWI_MAX_MULTS
2782 #define POWI_MAX_MULTS  (2*HOST_BITS_PER_WIDE_INT-2)
2783 #endif
2784
2785 /* The size of the "optimal power tree" lookup table.  All
2786    exponents less than this value are simply looked up in the
2787    powi_table below.  This threshold is also used to size the
2788    cache of pseudo registers that hold intermediate results.  */
2789 #define POWI_TABLE_SIZE 256
2790
2791 /* The size, in bits of the window, used in the "window method"
2792    exponentiation algorithm.  This is equivalent to a radix of
2793    (1<<POWI_WINDOW_SIZE) in the corresponding "m-ary method".  */
2794 #define POWI_WINDOW_SIZE 3
2795
2796 /* The following table is an efficient representation of an
2797    "optimal power tree".  For each value, i, the corresponding
2798    value, j, in the table states than an optimal evaluation
2799    sequence for calculating pow(x,i) can be found by evaluating
2800    pow(x,j)*pow(x,i-j).  An optimal power tree for the first
2801    100 integers is given in Knuth's "Seminumerical algorithms".  */
2802
2803 static const unsigned char powi_table[POWI_TABLE_SIZE] =
2804   {
2805       0,   1,   1,   2,   2,   3,   3,   4,  /*   0 -   7 */
2806       4,   6,   5,   6,   6,  10,   7,   9,  /*   8 -  15 */
2807       8,  16,   9,  16,  10,  12,  11,  13,  /*  16 -  23 */
2808      12,  17,  13,  18,  14,  24,  15,  26,  /*  24 -  31 */
2809      16,  17,  17,  19,  18,  33,  19,  26,  /*  32 -  39 */
2810      20,  25,  21,  40,  22,  27,  23,  44,  /*  40 -  47 */
2811      24,  32,  25,  34,  26,  29,  27,  44,  /*  48 -  55 */
2812      28,  31,  29,  34,  30,  60,  31,  36,  /*  56 -  63 */
2813      32,  64,  33,  34,  34,  46,  35,  37,  /*  64 -  71 */
2814      36,  65,  37,  50,  38,  48,  39,  69,  /*  72 -  79 */
2815      40,  49,  41,  43,  42,  51,  43,  58,  /*  80 -  87 */
2816      44,  64,  45,  47,  46,  59,  47,  76,  /*  88 -  95 */
2817      48,  65,  49,  66,  50,  67,  51,  66,  /*  96 - 103 */
2818      52,  70,  53,  74,  54, 104,  55,  74,  /* 104 - 111 */
2819      56,  64,  57,  69,  58,  78,  59,  68,  /* 112 - 119 */
2820      60,  61,  61,  80,  62,  75,  63,  68,  /* 120 - 127 */
2821      64,  65,  65, 128,  66, 129,  67,  90,  /* 128 - 135 */
2822      68,  73,  69, 131,  70,  94,  71,  88,  /* 136 - 143 */
2823      72, 128,  73,  98,  74, 132,  75, 121,  /* 144 - 151 */
2824      76, 102,  77, 124,  78, 132,  79, 106,  /* 152 - 159 */
2825      80,  97,  81, 160,  82,  99,  83, 134,  /* 160 - 167 */
2826      84,  86,  85,  95,  86, 160,  87, 100,  /* 168 - 175 */
2827      88, 113,  89,  98,  90, 107,  91, 122,  /* 176 - 183 */
2828      92, 111,  93, 102,  94, 126,  95, 150,  /* 184 - 191 */
2829      96, 128,  97, 130,  98, 133,  99, 195,  /* 192 - 199 */
2830     100, 128, 101, 123, 102, 164, 103, 138,  /* 200 - 207 */
2831     104, 145, 105, 146, 106, 109, 107, 149,  /* 208 - 215 */
2832     108, 200, 109, 146, 110, 170, 111, 157,  /* 216 - 223 */
2833     112, 128, 113, 130, 114, 182, 115, 132,  /* 224 - 231 */
2834     116, 200, 117, 132, 118, 158, 119, 206,  /* 232 - 239 */
2835     120, 240, 121, 162, 122, 147, 123, 152,  /* 240 - 247 */
2836     124, 166, 125, 214, 126, 138, 127, 153,  /* 248 - 255 */
2837   };
2838
2839
2840 /* Return the number of multiplications required to calculate
2841    powi(x,n) where n is less than POWI_TABLE_SIZE.  This is a
2842    subroutine of powi_cost.  CACHE is an array indicating
2843    which exponents have already been calculated.  */
2844
2845 static int
2846 powi_lookup_cost (unsigned HOST_WIDE_INT n, bool *cache)
2847 {
2848   /* If we've already calculated this exponent, then this evaluation
2849      doesn't require any additional multiplications.  */
2850   if (cache[n])
2851     return 0;
2852
2853   cache[n] = true;
2854   return powi_lookup_cost (n - powi_table[n], cache)
2855          + powi_lookup_cost (powi_table[n], cache) + 1;
2856 }
2857
2858 /* Return the number of multiplications required to calculate
2859    powi(x,n) for an arbitrary x, given the exponent N.  This
2860    function needs to be kept in sync with expand_powi below.  */
2861
2862 static int
2863 powi_cost (HOST_WIDE_INT n)
2864 {
2865   bool cache[POWI_TABLE_SIZE];
2866   unsigned HOST_WIDE_INT digit;
2867   unsigned HOST_WIDE_INT val;
2868   int result;
2869
2870   if (n == 0)
2871     return 0;
2872
2873   /* Ignore the reciprocal when calculating the cost.  */
2874   val = (n < 0) ? -n : n;
2875
2876   /* Initialize the exponent cache.  */
2877   memset (cache, 0, POWI_TABLE_SIZE * sizeof (bool));
2878   cache[1] = true;
2879
2880   result = 0;
2881
2882   while (val >= POWI_TABLE_SIZE)
2883     {
2884       if (val & 1)
2885         {
2886           digit = val & ((1 << POWI_WINDOW_SIZE) - 1);
2887           result += powi_lookup_cost (digit, cache)
2888                     + POWI_WINDOW_SIZE + 1;
2889           val >>= POWI_WINDOW_SIZE;
2890         }
2891       else
2892         {
2893           val >>= 1;
2894           result++;
2895         }
2896     }
2897
2898   return result + powi_lookup_cost (val, cache);
2899 }
2900
2901 /* Recursive subroutine of expand_powi.  This function takes the array,
2902    CACHE, of already calculated exponents and an exponent N and returns
2903    an RTX that corresponds to CACHE[1]**N, as calculated in mode MODE.  */
2904
2905 static rtx
2906 expand_powi_1 (enum machine_mode mode, unsigned HOST_WIDE_INT n, rtx *cache)
2907 {
2908   unsigned HOST_WIDE_INT digit;
2909   rtx target, result;
2910   rtx op0, op1;
2911
2912   if (n < POWI_TABLE_SIZE)
2913     {
2914       if (cache[n])
2915         return cache[n];
2916
2917       target = gen_reg_rtx (mode);
2918       cache[n] = target;
2919
2920       op0 = expand_powi_1 (mode, n - powi_table[n], cache);
2921       op1 = expand_powi_1 (mode, powi_table[n], cache);
2922     }
2923   else if (n & 1)
2924     {
2925       target = gen_reg_rtx (mode);
2926       digit = n & ((1 << POWI_WINDOW_SIZE) - 1);
2927       op0 = expand_powi_1 (mode, n - digit, cache);
2928       op1 = expand_powi_1 (mode, digit, cache);
2929     }
2930   else
2931     {
2932       target = gen_reg_rtx (mode);
2933       op0 = expand_powi_1 (mode, n >> 1, cache);
2934       op1 = op0;
2935     }
2936
2937   result = expand_mult (mode, op0, op1, target, 0);
2938   if (result != target)
2939     emit_move_insn (target, result);
2940   return target;
2941 }
2942
2943 /* Expand the RTL to evaluate powi(x,n) in mode MODE.  X is the
2944    floating point operand in mode MODE, and N is the exponent.  This
2945    function needs to be kept in sync with powi_cost above.  */
2946
2947 static rtx
2948 expand_powi (rtx x, enum machine_mode mode, HOST_WIDE_INT n)
2949 {
2950   rtx cache[POWI_TABLE_SIZE];
2951   rtx result;
2952
2953   if (n == 0)
2954     return CONST1_RTX (mode);
2955
2956   memset (cache, 0, sizeof (cache));
2957   cache[1] = x;
2958
2959   result = expand_powi_1 (mode, (n < 0) ? -n : n, cache);
2960
2961   /* If the original exponent was negative, reciprocate the result.  */
2962   if (n < 0)
2963     result = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
2964                            result, NULL_RTX, 0, OPTAB_LIB_WIDEN);
2965
2966   return result;
2967 }
2968
2969 /* Fold a builtin function call to pow, powf, or powl into a series of sqrts or
2970    cbrts.  Return NULL_RTX if no simplification can be made or expand the tree
2971    if we can simplify it.  */
2972 static rtx
2973 expand_builtin_pow_root (location_t loc, tree arg0, tree arg1, tree type,
2974                          rtx subtarget)
2975 {
2976   if (TREE_CODE (arg1) == REAL_CST
2977       && !TREE_OVERFLOW (arg1)
2978       && flag_unsafe_math_optimizations)
2979     {
2980       enum machine_mode mode = TYPE_MODE (type);
2981       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
2982       tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
2983       REAL_VALUE_TYPE c = TREE_REAL_CST (arg1);
2984       tree op = NULL_TREE;
2985
2986       if (sqrtfn)
2987         {
2988           /* Optimize pow (x, 0.5) into sqrt.  */
2989           if (REAL_VALUES_EQUAL (c, dconsthalf))
2990             op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
2991
2992           else
2993             {
2994               REAL_VALUE_TYPE dconst1_4 = dconst1;
2995               REAL_VALUE_TYPE dconst3_4;
2996               SET_REAL_EXP (&dconst1_4, REAL_EXP (&dconst1_4) - 2);
2997
2998               real_from_integer (&dconst3_4, VOIDmode, 3, 0, 0);
2999               SET_REAL_EXP (&dconst3_4, REAL_EXP (&dconst3_4) - 2);
3000
3001               /* Optimize pow (x, 0.25) into sqrt (sqrt (x)).  Assume on most
3002                  machines that a builtin sqrt instruction is smaller than a
3003                  call to pow with 0.25, so do this optimization even if
3004                  -Os.  */
3005               if (REAL_VALUES_EQUAL (c, dconst1_4))
3006                 {
3007                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3008                   op = build_call_nofold_loc (loc, sqrtfn, 1, op);
3009                 }
3010
3011               /* Optimize pow (x, 0.75) = sqrt (x) * sqrt (sqrt (x)) unless we
3012                  are optimizing for space.  */
3013               else if (optimize_insn_for_speed_p ()
3014                        && !TREE_SIDE_EFFECTS (arg0)
3015                        && REAL_VALUES_EQUAL (c, dconst3_4))
3016                 {
3017                   tree sqrt1 = build_call_expr_loc (loc, sqrtfn, 1, arg0);
3018                   tree sqrt2 = builtin_save_expr (sqrt1);
3019                   tree sqrt3 = build_call_expr_loc (loc, sqrtfn, 1, sqrt1);
3020                   op = fold_build2_loc (loc, MULT_EXPR, type, sqrt2, sqrt3);
3021                 }
3022             }
3023         }
3024
3025       /* Check whether we can do cbrt insstead of pow (x, 1./3.) and
3026          cbrt/sqrts instead of pow (x, 1./6.).  */
3027       if (cbrtfn && ! op
3028           && (tree_expr_nonnegative_p (arg0) || !HONOR_NANS (mode)))
3029         {
3030           /* First try 1/3.  */
3031           REAL_VALUE_TYPE dconst1_3
3032             = real_value_truncate (mode, dconst_third ());
3033
3034           if (REAL_VALUES_EQUAL (c, dconst1_3))
3035             op = build_call_nofold_loc (loc, cbrtfn, 1, arg0);
3036
3037               /* Now try 1/6.  */
3038           else if (optimize_insn_for_speed_p ())
3039             {
3040               REAL_VALUE_TYPE dconst1_6 = dconst1_3;
3041               SET_REAL_EXP (&dconst1_6, REAL_EXP (&dconst1_6) - 1);
3042
3043               if (REAL_VALUES_EQUAL (c, dconst1_6))
3044                 {
3045                   op = build_call_nofold_loc (loc, sqrtfn, 1, arg0);
3046                   op = build_call_nofold_loc (loc, cbrtfn, 1, op);
3047                 }
3048             }
3049         }
3050
3051       if (op)
3052         return expand_expr (op, subtarget, mode, EXPAND_NORMAL);
3053     }
3054
3055   return NULL_RTX;
3056 }
3057
3058 /* Expand a call to the pow built-in mathematical function.  Return NULL_RTX if
3059    a normal call should be emitted rather than expanding the function
3060    in-line.  EXP is the expression that is a call to the builtin
3061    function; if convenient, the result should be placed in TARGET.  */
3062
3063 static rtx
3064 expand_builtin_pow (tree exp, rtx target, rtx subtarget)
3065 {
3066   tree arg0, arg1;
3067   tree fn, narg0;
3068   tree type = TREE_TYPE (exp);
3069   REAL_VALUE_TYPE cint, c, c2;
3070   HOST_WIDE_INT n;
3071   rtx op, op2;
3072   enum machine_mode mode = TYPE_MODE (type);
3073
3074   if (! validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
3075     return NULL_RTX;
3076
3077   arg0 = CALL_EXPR_ARG (exp, 0);
3078   arg1 = CALL_EXPR_ARG (exp, 1);
3079
3080   if (TREE_CODE (arg1) != REAL_CST
3081       || TREE_OVERFLOW (arg1))
3082     return expand_builtin_mathfn_2 (exp, target, subtarget);
3083
3084   /* Handle constant exponents.  */
3085
3086   /* For integer valued exponents we can expand to an optimal multiplication
3087      sequence using expand_powi.  */
3088   c = TREE_REAL_CST (arg1);
3089   n = real_to_integer (&c);
3090   real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3091   if (real_identical (&c, &cint)
3092       && ((n >= -1 && n <= 2)
3093           || (flag_unsafe_math_optimizations
3094               && optimize_insn_for_speed_p ()
3095               && powi_cost (n) <= POWI_MAX_MULTS)))
3096     {
3097       op = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
3098       if (n != 1)
3099         {
3100           op = force_reg (mode, op);
3101           op = expand_powi (op, mode, n);
3102         }
3103       return op;
3104     }
3105
3106   narg0 = builtin_save_expr (arg0);
3107
3108   /* If the exponent is not integer valued, check if it is half of an integer.
3109      In this case we can expand to sqrt (x) * x**(n/2).  */
3110   fn = mathfn_built_in (type, BUILT_IN_SQRT);
3111   if (fn != NULL_TREE)
3112     {
3113       real_arithmetic (&c2, MULT_EXPR, &c, &dconst2);
3114       n = real_to_integer (&c2);
3115       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3116       if (real_identical (&c2, &cint)
3117           && ((flag_unsafe_math_optimizations
3118                && optimize_insn_for_speed_p ()
3119                && powi_cost (n/2) <= POWI_MAX_MULTS)
3120               /* Even the c == 0.5 case cannot be done unconditionally
3121                  when we need to preserve signed zeros, as
3122                  pow (-0, 0.5) is +0, while sqrt(-0) is -0.  */
3123               || (!HONOR_SIGNED_ZEROS (mode) && n == 1)
3124               /* For c == 1.5 we can assume that x * sqrt (x) is always
3125                  smaller than pow (x, 1.5) if sqrt will not be expanded
3126                  as a call.  */
3127               || (n == 3
3128                   && optab_handler (sqrt_optab, mode) != CODE_FOR_nothing)))
3129         {
3130           tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3131                                                   narg0);
3132           /* Use expand_expr in case the newly built call expression
3133              was folded to a non-call.  */
3134           op = expand_expr (call_expr, subtarget, mode, EXPAND_NORMAL);
3135           if (n != 1)
3136             {
3137               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3138               op2 = force_reg (mode, op2);
3139               op2 = expand_powi (op2, mode, abs (n / 2));
3140               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3141                                         0, OPTAB_LIB_WIDEN);
3142               /* If the original exponent was negative, reciprocate the
3143                  result.  */
3144               if (n < 0)
3145                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3146                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3147             }
3148           return op;
3149         }
3150     }
3151
3152   /* Check whether we can do a series of sqrt or cbrt's instead of the pow
3153      call.  */
3154   op = expand_builtin_pow_root (EXPR_LOCATION (exp), arg0, arg1, type,
3155                                 subtarget);
3156   if (op)
3157     return op;
3158
3159   /* Try if the exponent is a third of an integer.  In this case
3160      we can expand to x**(n/3) * cbrt(x)**(n%3).  As cbrt (x) is
3161      different from pow (x, 1./3.) due to rounding and behavior
3162      with negative x we need to constrain this transformation to
3163      unsafe math and positive x or finite math.  */
3164   fn = mathfn_built_in (type, BUILT_IN_CBRT);
3165   if (fn != NULL_TREE
3166       && flag_unsafe_math_optimizations
3167       && (tree_expr_nonnegative_p (arg0)
3168           || !HONOR_NANS (mode)))
3169     {
3170       REAL_VALUE_TYPE dconst3;
3171       real_from_integer (&dconst3, VOIDmode, 3, 0, 0);
3172       real_arithmetic (&c2, MULT_EXPR, &c, &dconst3);
3173       real_round (&c2, mode, &c2);
3174       n = real_to_integer (&c2);
3175       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
3176       real_arithmetic (&c2, RDIV_EXPR, &cint, &dconst3);
3177       real_convert (&c2, mode, &c2);
3178       if (real_identical (&c2, &c)
3179           && ((optimize_insn_for_speed_p ()
3180                && powi_cost (n/3) <= POWI_MAX_MULTS)
3181               || n == 1))
3182         {
3183           tree call_expr = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 1,
3184                                                   narg0);
3185           op = expand_builtin (call_expr, NULL_RTX, subtarget, mode, 0);
3186           if (abs (n) % 3 == 2)
3187             op = expand_simple_binop (mode, MULT, op, op, op,
3188                                       0, OPTAB_LIB_WIDEN);
3189           if (n != 1)
3190             {
3191               op2 = expand_expr (narg0, subtarget, VOIDmode, EXPAND_NORMAL);
3192               op2 = force_reg (mode, op2);
3193               op2 = expand_powi (op2, mode, abs (n / 3));
3194               op = expand_simple_binop (mode, MULT, op, op2, NULL_RTX,
3195                                         0, OPTAB_LIB_WIDEN);
3196               /* If the original exponent was negative, reciprocate the
3197                  result.  */
3198               if (n < 0)
3199                 op = expand_binop (mode, sdiv_optab, CONST1_RTX (mode),
3200                                    op, NULL_RTX, 0, OPTAB_LIB_WIDEN);
3201             }
3202           return op;
3203         }
3204     }
3205
3206   /* Fall back to optab expansion.  */
3207   return expand_builtin_mathfn_2 (exp, target, subtarget);
3208 }
3209
3210 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
3211    a normal call should be emitted rather than expanding the function
3212    in-line.  EXP is the expression that is a call to the builtin
3213    function; if convenient, the result should be placed in TARGET.  */
3214
3215 static rtx
3216 expand_builtin_powi (tree exp, rtx target)
3217 {
3218   tree arg0, arg1;
3219   rtx op0, op1;
3220   enum machine_mode mode;
3221   enum machine_mode mode2;
3222
3223   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
3224     return NULL_RTX;
3225
3226   arg0 = CALL_EXPR_ARG (exp, 0);
3227   arg1 = CALL_EXPR_ARG (exp, 1);
3228   mode = TYPE_MODE (TREE_TYPE (exp));
3229
3230   /* Handle constant power.  */
3231
3232   if (TREE_CODE (arg1) == INTEGER_CST
3233       && !TREE_OVERFLOW (arg1))
3234     {
3235       HOST_WIDE_INT n = TREE_INT_CST_LOW (arg1);
3236
3237       /* If the exponent is -1, 0, 1 or 2, then expand_powi is exact.
3238          Otherwise, check the number of multiplications required.  */
3239       if ((TREE_INT_CST_HIGH (arg1) == 0
3240            || TREE_INT_CST_HIGH (arg1) == -1)
3241           && ((n >= -1 && n <= 2)
3242               || (optimize_insn_for_speed_p ()
3243                   && powi_cost (n) <= POWI_MAX_MULTS)))
3244         {
3245           op0 = expand_expr (arg0, NULL_RTX, VOIDmode, EXPAND_NORMAL);
3246           op0 = force_reg (mode, op0);
3247           return expand_powi (op0, mode, n);
3248         }
3249     }
3250
3251   /* Emit a libcall to libgcc.  */
3252
3253   /* Mode of the 2nd argument must match that of an int.  */
3254   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
3255
3256   if (target == NULL_RTX)
3257     target = gen_reg_rtx (mode);
3258
3259   op0 = expand_expr (arg0, NULL_RTX, mode, EXPAND_NORMAL);
3260   if (GET_MODE (op0) != mode)
3261     op0 = convert_to_mode (mode, op0, 0);
3262   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
3263   if (GET_MODE (op1) != mode2)
3264     op1 = convert_to_mode (mode2, op1, 0);
3265
3266   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
3267                                     target, LCT_CONST, mode, 2,
3268                                     op0, mode, op1, mode2);
3269
3270   return target;
3271 }
3272
3273 /* Expand expression EXP which is a call to the strlen builtin.  Return
3274    NULL_RTX if we failed the caller should emit a normal call, otherwise
3275    try to get the result in TARGET, if convenient.  */
3276
3277 static rtx
3278 expand_builtin_strlen (tree exp, rtx target,
3279                        enum machine_mode target_mode)
3280 {
3281   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
3282     return NULL_RTX;
3283   else
3284     {
3285       rtx pat;
3286       tree len;
3287       tree src = CALL_EXPR_ARG (exp, 0);
3288       rtx result, src_reg, char_rtx, before_strlen;
3289       enum machine_mode insn_mode = target_mode, char_mode;
3290       enum insn_code icode = CODE_FOR_nothing;
3291       unsigned int align;
3292
3293       /* If the length can be computed at compile-time, return it.  */
3294       len = c_strlen (src, 0);
3295       if (len)
3296         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3297
3298       /* If the length can be computed at compile-time and is constant
3299          integer, but there are side-effects in src, evaluate
3300          src for side-effects, then return len.
3301          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
3302          can be optimized into: i++; x = 3;  */
3303       len = c_strlen (src, 1);
3304       if (len && TREE_CODE (len) == INTEGER_CST)
3305         {
3306           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
3307           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
3308         }
3309
3310       align = get_pointer_alignment (src, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
3311
3312       /* If SRC is not a pointer type, don't do this operation inline.  */
3313       if (align == 0)
3314         return NULL_RTX;
3315
3316       /* Bail out if we can't compute strlen in the right mode.  */
3317       while (insn_mode != VOIDmode)
3318         {
3319           icode = optab_handler (strlen_optab, insn_mode);
3320           if (icode != CODE_FOR_nothing)
3321             break;
3322
3323           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
3324         }
3325       if (insn_mode == VOIDmode)
3326         return NULL_RTX;
3327
3328       /* Make a place to write the result of the instruction.  */
3329       result = target;
3330       if (! (result != 0
3331              && REG_P (result)
3332              && GET_MODE (result) == insn_mode
3333              && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3334         result = gen_reg_rtx (insn_mode);
3335
3336       /* Make a place to hold the source address.  We will not expand
3337          the actual source until we are sure that the expansion will
3338          not fail -- there are trees that cannot be expanded twice.  */
3339       src_reg = gen_reg_rtx (Pmode);
3340
3341       /* Mark the beginning of the strlen sequence so we can emit the
3342          source operand later.  */
3343       before_strlen = get_last_insn ();
3344
3345       char_rtx = const0_rtx;
3346       char_mode = insn_data[(int) icode].operand[2].mode;
3347       if (! (*insn_data[(int) icode].operand[2].predicate) (char_rtx,
3348                                                             char_mode))
3349         char_rtx = copy_to_mode_reg (char_mode, char_rtx);
3350
3351       pat = GEN_FCN (icode) (result, gen_rtx_MEM (BLKmode, src_reg),
3352                              char_rtx, GEN_INT (align));
3353       if (! pat)
3354         return NULL_RTX;
3355       emit_insn (pat);
3356
3357       /* Now that we are assured of success, expand the source.  */
3358       start_sequence ();
3359       pat = expand_expr (src, src_reg, ptr_mode, EXPAND_NORMAL);
3360       if (pat != src_reg)
3361         emit_move_insn (src_reg, pat);
3362       pat = get_insns ();
3363       end_sequence ();
3364
3365       if (before_strlen)
3366         emit_insn_after (pat, before_strlen);
3367       else
3368         emit_insn_before (pat, get_insns ());
3369
3370       /* Return the value in the proper mode for this function.  */
3371       if (GET_MODE (result) == target_mode)
3372         target = result;
3373       else if (target != 0)
3374         convert_move (target, result, 0);
3375       else
3376         target = convert_to_mode (target_mode, result, 0);
3377
3378       return target;
3379     }
3380 }
3381
3382 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3383    bytes from constant string DATA + OFFSET and return it as target
3384    constant.  */
3385
3386 static rtx
3387 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3388                          enum machine_mode mode)
3389 {
3390   const char *str = (const char *) data;
3391
3392   gcc_assert (offset >= 0
3393               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3394                   <= strlen (str) + 1));
3395
3396   return c_readstr (str + offset, mode);
3397 }
3398
3399 /* Expand a call EXP to the memcpy builtin.
3400    Return NULL_RTX if we failed, the caller should emit a normal call,
3401    otherwise try to get the result in TARGET, if convenient (and in
3402    mode MODE if that's convenient).  */
3403
3404 static rtx
3405 expand_builtin_memcpy (tree exp, rtx target)
3406 {
3407   if (!validate_arglist (exp,
3408                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3409     return NULL_RTX;
3410   else
3411     {
3412       tree dest = CALL_EXPR_ARG (exp, 0);
3413       tree src = CALL_EXPR_ARG (exp, 1);
3414       tree len = CALL_EXPR_ARG (exp, 2);
3415       const char *src_str;
3416       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3417       unsigned int dest_align
3418         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3419       rtx dest_mem, src_mem, dest_addr, len_rtx;
3420       HOST_WIDE_INT expected_size = -1;
3421       unsigned int expected_align = 0;
3422
3423       /* If DEST is not a pointer type, call the normal function.  */
3424       if (dest_align == 0)
3425         return NULL_RTX;
3426
3427       /* If either SRC is not a pointer type, don't do this
3428          operation in-line.  */
3429       if (src_align == 0)
3430         return NULL_RTX;
3431
3432       if (currently_expanding_gimple_stmt)
3433         stringop_block_profile (currently_expanding_gimple_stmt,
3434                                 &expected_align, &expected_size);
3435
3436       if (expected_align < dest_align)
3437         expected_align = dest_align;
3438       dest_mem = get_memory_rtx (dest, len);
3439       set_mem_align (dest_mem, dest_align);
3440       len_rtx = expand_normal (len);
3441       src_str = c_getstr (src);
3442
3443       /* If SRC is a string constant and block move would be done
3444          by pieces, we can avoid loading the string from memory
3445          and only stored the computed constants.  */
3446       if (src_str
3447           && CONST_INT_P (len_rtx)
3448           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3449           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3450                                   CONST_CAST (char *, src_str),
3451                                   dest_align, false))
3452         {
3453           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3454                                       builtin_memcpy_read_str,
3455                                       CONST_CAST (char *, src_str),
3456                                       dest_align, false, 0);
3457           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3458           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3459           return dest_mem;
3460         }
3461
3462       src_mem = get_memory_rtx (src, len);
3463       set_mem_align (src_mem, src_align);
3464
3465       /* Copy word part most expediently.  */
3466       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3467                                          CALL_EXPR_TAILCALL (exp)
3468                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3469                                          expected_align, expected_size);
3470
3471       if (dest_addr == 0)
3472         {
3473           dest_addr = force_operand (XEXP (dest_mem, 0), target);
3474           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3475         }
3476       return dest_addr;
3477     }
3478 }
3479
3480 /* Expand a call EXP to the mempcpy builtin.
3481    Return NULL_RTX if we failed; the caller should emit a normal call,
3482    otherwise try to get the result in TARGET, if convenient (and in
3483    mode MODE if that's convenient).  If ENDP is 0 return the
3484    destination pointer, if ENDP is 1 return the end pointer ala
3485    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3486    stpcpy.  */
3487
3488 static rtx
3489 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3490 {
3491   if (!validate_arglist (exp,
3492                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3493     return NULL_RTX;
3494   else
3495     {
3496       tree dest = CALL_EXPR_ARG (exp, 0);
3497       tree src = CALL_EXPR_ARG (exp, 1);
3498       tree len = CALL_EXPR_ARG (exp, 2);
3499       return expand_builtin_mempcpy_args (dest, src, len,
3500                                           target, mode, /*endp=*/ 1);
3501     }
3502 }
3503
3504 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3505    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3506    so that this can also be called without constructing an actual CALL_EXPR.
3507    The other arguments and return value are the same as for
3508    expand_builtin_mempcpy.  */
3509
3510 static rtx
3511 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3512                              rtx target, enum machine_mode mode, int endp)
3513 {
3514     /* If return value is ignored, transform mempcpy into memcpy.  */
3515   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_MEMCPY])
3516     {
3517       tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
3518       tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3519                                            dest, src, len);
3520       return expand_expr (result, target, mode, EXPAND_NORMAL);
3521     }
3522   else
3523     {
3524       const char *src_str;
3525       unsigned int src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
3526       unsigned int dest_align
3527         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3528       rtx dest_mem, src_mem, len_rtx;
3529
3530       /* If either SRC or DEST is not a pointer type, don't do this
3531          operation in-line.  */
3532       if (dest_align == 0 || src_align == 0)
3533         return NULL_RTX;
3534
3535       /* If LEN is not constant, call the normal function.  */
3536       if (! host_integerp (len, 1))
3537         return NULL_RTX;
3538
3539       len_rtx = expand_normal (len);
3540       src_str = c_getstr (src);
3541
3542       /* If SRC is a string constant and block move would be done
3543          by pieces, we can avoid loading the string from memory
3544          and only stored the computed constants.  */
3545       if (src_str
3546           && CONST_INT_P (len_rtx)
3547           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3548           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3549                                   CONST_CAST (char *, src_str),
3550                                   dest_align, false))
3551         {
3552           dest_mem = get_memory_rtx (dest, len);
3553           set_mem_align (dest_mem, dest_align);
3554           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3555                                       builtin_memcpy_read_str,
3556                                       CONST_CAST (char *, src_str),
3557                                       dest_align, false, endp);
3558           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3559           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3560           return dest_mem;
3561         }
3562
3563       if (CONST_INT_P (len_rtx)
3564           && can_move_by_pieces (INTVAL (len_rtx),
3565                                  MIN (dest_align, src_align)))
3566         {
3567           dest_mem = get_memory_rtx (dest, len);
3568           set_mem_align (dest_mem, dest_align);
3569           src_mem = get_memory_rtx (src, len);
3570           set_mem_align (src_mem, src_align);
3571           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3572                                      MIN (dest_align, src_align), endp);
3573           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3574           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3575           return dest_mem;
3576         }
3577
3578       return NULL_RTX;
3579     }
3580 }
3581
3582 #ifndef HAVE_movstr
3583 # define HAVE_movstr 0
3584 # define CODE_FOR_movstr CODE_FOR_nothing
3585 #endif
3586
3587 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3588    we failed, the caller should emit a normal call, otherwise try to
3589    get the result in TARGET, if convenient.  If ENDP is 0 return the
3590    destination pointer, if ENDP is 1 return the end pointer ala
3591    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3592    stpcpy.  */
3593
3594 static rtx
3595 expand_movstr (tree dest, tree src, rtx target, int endp)
3596 {
3597   rtx end;
3598   rtx dest_mem;
3599   rtx src_mem;
3600   rtx insn;
3601   const struct insn_data_d * data;
3602
3603   if (!HAVE_movstr)
3604     return NULL_RTX;
3605
3606   dest_mem = get_memory_rtx (dest, NULL);
3607   src_mem = get_memory_rtx (src, NULL);
3608   data = insn_data + CODE_FOR_movstr;
3609   if (!endp)
3610     {
3611       target = force_reg (Pmode, XEXP (dest_mem, 0));
3612       dest_mem = replace_equiv_address (dest_mem, target);
3613       end = gen_reg_rtx (Pmode);
3614     }
3615   else
3616     {
3617       if (target == 0
3618           || target == const0_rtx
3619           || ! (*data->operand[0].predicate) (target, Pmode))
3620         {
3621           end = gen_reg_rtx (Pmode);
3622           if (target != const0_rtx)
3623             target = end;
3624         }
3625       else
3626         end = target;
3627     }
3628
3629   if (data->operand[0].mode != VOIDmode)
3630     end = gen_lowpart (data->operand[0].mode, end);
3631
3632   insn = data->genfun (end, dest_mem, src_mem);
3633
3634   gcc_assert (insn);
3635
3636   emit_insn (insn);
3637
3638   /* movstr is supposed to set end to the address of the NUL
3639      terminator.  If the caller requested a mempcpy-like return value,
3640      adjust it.  */
3641   if (endp == 1 && target != const0_rtx)
3642     {
3643       rtx tem = plus_constant (gen_lowpart (GET_MODE (target), end), 1);
3644       emit_move_insn (target, force_operand (tem, NULL_RTX));
3645     }
3646
3647   return target;
3648 }
3649
3650 /* Expand expression EXP, which is a call to the strcpy builtin.  Return
3651    NULL_RTX if we failed the caller should emit a normal call, otherwise
3652    try to get the result in TARGET, if convenient (and in mode MODE if that's
3653    convenient).  */
3654
3655 static rtx
3656 expand_builtin_strcpy (tree exp, rtx target)
3657 {
3658   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3659    {
3660      tree dest = CALL_EXPR_ARG (exp, 0);
3661      tree src = CALL_EXPR_ARG (exp, 1);
3662      return expand_builtin_strcpy_args (dest, src, target);
3663    }
3664    return NULL_RTX;
3665 }
3666
3667 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3668    arguments to the builtin_strcpy call DEST and SRC are broken out
3669    so that this can also be called without constructing an actual CALL_EXPR.
3670    The other arguments and return value are the same as for
3671    expand_builtin_strcpy.  */
3672
3673 static rtx
3674 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3675 {
3676   return expand_movstr (dest, src, target, /*endp=*/0);
3677 }
3678
3679 /* Expand a call EXP to the stpcpy builtin.
3680    Return NULL_RTX if we failed the caller should emit a normal call,
3681    otherwise try to get the result in TARGET, if convenient (and in
3682    mode MODE if that's convenient).  */
3683
3684 static rtx
3685 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3686 {
3687   tree dst, src;
3688   location_t loc = EXPR_LOCATION (exp);
3689
3690   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3691     return NULL_RTX;
3692
3693   dst = CALL_EXPR_ARG (exp, 0);
3694   src = CALL_EXPR_ARG (exp, 1);
3695
3696   /* If return value is ignored, transform stpcpy into strcpy.  */
3697   if (target == const0_rtx && implicit_built_in_decls[BUILT_IN_STRCPY])
3698     {
3699       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
3700       tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3701       return expand_expr (result, target, mode, EXPAND_NORMAL);
3702     }
3703   else
3704     {
3705       tree len, lenp1;
3706       rtx ret;
3707
3708       /* Ensure we get an actual string whose length can be evaluated at
3709          compile-time, not an expression containing a string.  This is
3710          because the latter will potentially produce pessimized code
3711          when used to produce the return value.  */
3712       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3713         return expand_movstr (dst, src, target, /*endp=*/2);
3714
3715       lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3716       ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3717                                          target, mode, /*endp=*/2);
3718
3719       if (ret)
3720         return ret;
3721
3722       if (TREE_CODE (len) == INTEGER_CST)
3723         {
3724           rtx len_rtx = expand_normal (len);
3725
3726           if (CONST_INT_P (len_rtx))
3727             {
3728               ret = expand_builtin_strcpy_args (dst, src, target);
3729
3730               if (ret)
3731                 {
3732                   if (! target)
3733                     {
3734                       if (mode != VOIDmode)
3735                         target = gen_reg_rtx (mode);
3736                       else
3737                         target = gen_reg_rtx (GET_MODE (ret));
3738                     }
3739                   if (GET_MODE (target) != GET_MODE (ret))
3740                     ret = gen_lowpart (GET_MODE (target), ret);
3741
3742                   ret = plus_constant (ret, INTVAL (len_rtx));
3743                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3744                   gcc_assert (ret);
3745
3746                   return target;
3747                 }
3748             }
3749         }
3750
3751       return expand_movstr (dst, src, target, /*endp=*/2);
3752     }
3753 }
3754
3755 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3756    bytes from constant string DATA + OFFSET and return it as target
3757    constant.  */
3758
3759 rtx
3760 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3761                           enum machine_mode mode)
3762 {
3763   const char *str = (const char *) data;
3764
3765   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3766     return const0_rtx;
3767
3768   return c_readstr (str + offset, mode);
3769 }
3770
3771 /* Expand expression EXP, which is a call to the strncpy builtin.  Return
3772    NULL_RTX if we failed the caller should emit a normal call.  */
3773
3774 static rtx
3775 expand_builtin_strncpy (tree exp, rtx target)
3776 {
3777   location_t loc = EXPR_LOCATION (exp);
3778
3779   if (validate_arglist (exp,
3780                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3781     {
3782       tree dest = CALL_EXPR_ARG (exp, 0);
3783       tree src = CALL_EXPR_ARG (exp, 1);
3784       tree len = CALL_EXPR_ARG (exp, 2);
3785       tree slen = c_strlen (src, 1);
3786
3787       /* We must be passed a constant len and src parameter.  */
3788       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3789         return NULL_RTX;
3790
3791       slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3792
3793       /* We're required to pad with trailing zeros if the requested
3794          len is greater than strlen(s2)+1.  In that case try to
3795          use store_by_pieces, if it fails, punt.  */
3796       if (tree_int_cst_lt (slen, len))
3797         {
3798           unsigned int dest_align
3799             = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3800           const char *p = c_getstr (src);
3801           rtx dest_mem;
3802
3803           if (!p || dest_align == 0 || !host_integerp (len, 1)
3804               || !can_store_by_pieces (tree_low_cst (len, 1),
3805                                        builtin_strncpy_read_str,
3806                                        CONST_CAST (char *, p),
3807                                        dest_align, false))
3808             return NULL_RTX;
3809
3810           dest_mem = get_memory_rtx (dest, len);
3811           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3812                            builtin_strncpy_read_str,
3813                            CONST_CAST (char *, p), dest_align, false, 0);
3814           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3815           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3816           return dest_mem;
3817         }
3818     }
3819   return NULL_RTX;
3820 }
3821
3822 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3823    bytes from constant string DATA + OFFSET and return it as target
3824    constant.  */
3825
3826 rtx
3827 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3828                          enum machine_mode mode)
3829 {
3830   const char *c = (const char *) data;
3831   char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3832
3833   memset (p, *c, GET_MODE_SIZE (mode));
3834
3835   return c_readstr (p, mode);
3836 }
3837
3838 /* Callback routine for store_by_pieces.  Return the RTL of a register
3839    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3840    char value given in the RTL register data.  For example, if mode is
3841    4 bytes wide, return the RTL for 0x01010101*data.  */
3842
3843 static rtx
3844 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3845                         enum machine_mode mode)
3846 {
3847   rtx target, coeff;
3848   size_t size;
3849   char *p;
3850
3851   size = GET_MODE_SIZE (mode);
3852   if (size == 1)
3853     return (rtx) data;
3854
3855   p = XALLOCAVEC (char, size);
3856   memset (p, 1, size);
3857   coeff = c_readstr (p, mode);
3858
3859   target = convert_to_mode (mode, (rtx) data, 1);
3860   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3861   return force_reg (mode, target);
3862 }
3863
3864 /* Expand expression EXP, which is a call to the memset builtin.  Return
3865    NULL_RTX if we failed the caller should emit a normal call, otherwise
3866    try to get the result in TARGET, if convenient (and in mode MODE if that's
3867    convenient).  */
3868
3869 static rtx
3870 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3871 {
3872   if (!validate_arglist (exp,
3873                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3874     return NULL_RTX;
3875   else
3876     {
3877       tree dest = CALL_EXPR_ARG (exp, 0);
3878       tree val = CALL_EXPR_ARG (exp, 1);
3879       tree len = CALL_EXPR_ARG (exp, 2);
3880       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3881     }
3882 }
3883
3884 /* Helper function to do the actual work for expand_builtin_memset.  The
3885    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3886    so that this can also be called without constructing an actual CALL_EXPR.
3887    The other arguments and return value are the same as for
3888    expand_builtin_memset.  */
3889
3890 static rtx
3891 expand_builtin_memset_args (tree dest, tree val, tree len,
3892                             rtx target, enum machine_mode mode, tree orig_exp)
3893 {
3894   tree fndecl, fn;
3895   enum built_in_function fcode;
3896   char c;
3897   unsigned int dest_align;
3898   rtx dest_mem, dest_addr, len_rtx;
3899   HOST_WIDE_INT expected_size = -1;
3900   unsigned int expected_align = 0;
3901
3902   dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
3903
3904   /* If DEST is not a pointer type, don't do this operation in-line.  */
3905   if (dest_align == 0)
3906     return NULL_RTX;
3907
3908   if (currently_expanding_gimple_stmt)
3909     stringop_block_profile (currently_expanding_gimple_stmt,
3910                             &expected_align, &expected_size);
3911
3912   if (expected_align < dest_align)
3913     expected_align = dest_align;
3914
3915   /* If the LEN parameter is zero, return DEST.  */
3916   if (integer_zerop (len))
3917     {
3918       /* Evaluate and ignore VAL in case it has side-effects.  */
3919       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3920       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3921     }
3922
3923   /* Stabilize the arguments in case we fail.  */
3924   dest = builtin_save_expr (dest);
3925   val = builtin_save_expr (val);
3926   len = builtin_save_expr (len);
3927
3928   len_rtx = expand_normal (len);
3929   dest_mem = get_memory_rtx (dest, len);
3930
3931   if (TREE_CODE (val) != INTEGER_CST)
3932     {
3933       rtx val_rtx;
3934
3935       val_rtx = expand_normal (val);
3936       val_rtx = convert_to_mode (TYPE_MODE (unsigned_char_type_node),
3937                                  val_rtx, 0);
3938
3939       /* Assume that we can memset by pieces if we can store
3940        * the coefficients by pieces (in the required modes).
3941        * We can't pass builtin_memset_gen_str as that emits RTL.  */
3942       c = 1;
3943       if (host_integerp (len, 1)
3944           && can_store_by_pieces (tree_low_cst (len, 1),
3945                                   builtin_memset_read_str, &c, dest_align,
3946                                   true))
3947         {
3948           val_rtx = force_reg (TYPE_MODE (unsigned_char_type_node),
3949                                val_rtx);
3950           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3951                            builtin_memset_gen_str, val_rtx, dest_align,
3952                            true, 0);
3953         }
3954       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3955                                         dest_align, expected_align,
3956                                         expected_size))
3957         goto do_libcall;
3958
3959       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3960       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3961       return dest_mem;
3962     }
3963
3964   if (target_char_cast (val, &c))
3965     goto do_libcall;
3966
3967   if (c)
3968     {
3969       if (host_integerp (len, 1)
3970           && can_store_by_pieces (tree_low_cst (len, 1),
3971                                   builtin_memset_read_str, &c, dest_align,
3972                                   true))
3973         store_by_pieces (dest_mem, tree_low_cst (len, 1),
3974                          builtin_memset_read_str, &c, dest_align, true, 0);
3975       else if (!set_storage_via_setmem (dest_mem, len_rtx, GEN_INT (c),
3976                                         dest_align, expected_align,
3977                                         expected_size))
3978         goto do_libcall;
3979
3980       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3981       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3982       return dest_mem;
3983     }
3984
3985   set_mem_align (dest_mem, dest_align);
3986   dest_addr = clear_storage_hints (dest_mem, len_rtx,
3987                                    CALL_EXPR_TAILCALL (orig_exp)
3988                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3989                                    expected_align, expected_size);
3990
3991   if (dest_addr == 0)
3992     {
3993       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3994       dest_addr = convert_memory_address (ptr_mode, dest_addr);
3995     }
3996
3997   return dest_addr;
3998
3999  do_libcall:
4000   fndecl = get_callee_fndecl (orig_exp);
4001   fcode = DECL_FUNCTION_CODE (fndecl);
4002   if (fcode == BUILT_IN_MEMSET)
4003     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
4004                                 dest, val, len);
4005   else if (fcode == BUILT_IN_BZERO)
4006     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
4007                                 dest, len);
4008   else
4009     gcc_unreachable ();
4010   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4011   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
4012   return expand_call (fn, target, target == const0_rtx);
4013 }
4014
4015 /* Expand expression EXP, which is a call to the bzero builtin.  Return
4016    NULL_RTX if we failed the caller should emit a normal call.  */
4017
4018 static rtx
4019 expand_builtin_bzero (tree exp)
4020 {
4021   tree dest, size;
4022   location_t loc = EXPR_LOCATION (exp);
4023
4024   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4025     return NULL_RTX;
4026
4027   dest = CALL_EXPR_ARG (exp, 0);
4028   size = CALL_EXPR_ARG (exp, 1);
4029
4030   /* New argument list transforming bzero(ptr x, int y) to
4031      memset(ptr x, int 0, size_t y).   This is done this way
4032      so that if it isn't expanded inline, we fallback to
4033      calling bzero instead of memset.  */
4034
4035   return expand_builtin_memset_args (dest, integer_zero_node,
4036                                      fold_convert_loc (loc, sizetype, size),
4037                                      const0_rtx, VOIDmode, exp);
4038 }
4039
4040 /* Expand expression EXP, which is a call to the memcmp built-in function.
4041    Return NULL_RTX if we failed and the
4042    caller should emit a normal call, otherwise try to get the result in
4043    TARGET, if convenient (and in mode MODE, if that's convenient).  */
4044
4045 static rtx
4046 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4047                        ATTRIBUTE_UNUSED enum machine_mode mode)
4048 {
4049   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4050
4051   if (!validate_arglist (exp,
4052                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4053     return NULL_RTX;
4054
4055 #if defined HAVE_cmpmemsi || defined HAVE_cmpstrnsi
4056   {
4057     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4058     rtx result;
4059     rtx insn;
4060     tree arg1 = CALL_EXPR_ARG (exp, 0);
4061     tree arg2 = CALL_EXPR_ARG (exp, 1);
4062     tree len = CALL_EXPR_ARG (exp, 2);
4063
4064     unsigned int arg1_align
4065       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4066     unsigned int arg2_align
4067       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4068     enum machine_mode insn_mode;
4069
4070 #ifdef HAVE_cmpmemsi
4071     if (HAVE_cmpmemsi)
4072       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
4073     else
4074 #endif
4075 #ifdef HAVE_cmpstrnsi
4076     if (HAVE_cmpstrnsi)
4077       insn_mode = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4078     else
4079 #endif
4080       return NULL_RTX;
4081
4082     /* If we don't have POINTER_TYPE, call the function.  */
4083     if (arg1_align == 0 || arg2_align == 0)
4084       return NULL_RTX;
4085
4086     /* Make a place to write the result of the instruction.  */
4087     result = target;
4088     if (! (result != 0
4089            && REG_P (result) && GET_MODE (result) == insn_mode
4090            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4091       result = gen_reg_rtx (insn_mode);
4092
4093     arg1_rtx = get_memory_rtx (arg1, len);
4094     arg2_rtx = get_memory_rtx (arg2, len);
4095     arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
4096
4097     /* Set MEM_SIZE as appropriate.  */
4098     if (CONST_INT_P (arg3_rtx))
4099       {
4100         set_mem_size (arg1_rtx, arg3_rtx);
4101         set_mem_size (arg2_rtx, arg3_rtx);
4102       }
4103
4104 #ifdef HAVE_cmpmemsi
4105     if (HAVE_cmpmemsi)
4106       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4107                            GEN_INT (MIN (arg1_align, arg2_align)));
4108     else
4109 #endif
4110 #ifdef HAVE_cmpstrnsi
4111     if (HAVE_cmpstrnsi)
4112       insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4113                             GEN_INT (MIN (arg1_align, arg2_align)));
4114     else
4115 #endif
4116       gcc_unreachable ();
4117
4118     if (insn)
4119       emit_insn (insn);
4120     else
4121       emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
4122                                TYPE_MODE (integer_type_node), 3,
4123                                XEXP (arg1_rtx, 0), Pmode,
4124                                XEXP (arg2_rtx, 0), Pmode,
4125                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
4126                                                 TYPE_UNSIGNED (sizetype)),
4127                                TYPE_MODE (sizetype));
4128
4129     /* Return the value in the proper mode for this function.  */
4130     mode = TYPE_MODE (TREE_TYPE (exp));
4131     if (GET_MODE (result) == mode)
4132       return result;
4133     else if (target != 0)
4134       {
4135         convert_move (target, result, 0);
4136         return target;
4137       }
4138     else
4139       return convert_to_mode (mode, result, 0);
4140   }
4141 #endif
4142
4143   return NULL_RTX;
4144 }
4145
4146 /* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
4147    if we failed the caller should emit a normal call, otherwise try to get
4148    the result in TARGET, if convenient.  */
4149
4150 static rtx
4151 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
4152 {
4153   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4154     return NULL_RTX;
4155
4156 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
4157   if (direct_optab_handler (cmpstr_optab, SImode) != CODE_FOR_nothing
4158       || direct_optab_handler (cmpstrn_optab, SImode) != CODE_FOR_nothing)
4159     {
4160       rtx arg1_rtx, arg2_rtx;
4161       rtx result, insn = NULL_RTX;
4162       tree fndecl, fn;
4163       tree arg1 = CALL_EXPR_ARG (exp, 0);
4164       tree arg2 = CALL_EXPR_ARG (exp, 1);
4165
4166       unsigned int arg1_align
4167         = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4168       unsigned int arg2_align
4169         = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4170
4171       /* If we don't have POINTER_TYPE, call the function.  */
4172       if (arg1_align == 0 || arg2_align == 0)
4173         return NULL_RTX;
4174
4175       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
4176       arg1 = builtin_save_expr (arg1);
4177       arg2 = builtin_save_expr (arg2);
4178
4179       arg1_rtx = get_memory_rtx (arg1, NULL);
4180       arg2_rtx = get_memory_rtx (arg2, NULL);
4181
4182 #ifdef HAVE_cmpstrsi
4183       /* Try to call cmpstrsi.  */
4184       if (HAVE_cmpstrsi)
4185         {
4186           enum machine_mode insn_mode
4187             = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
4188
4189           /* Make a place to write the result of the instruction.  */
4190           result = target;
4191           if (! (result != 0
4192                  && REG_P (result) && GET_MODE (result) == insn_mode
4193                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4194             result = gen_reg_rtx (insn_mode);
4195
4196           insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
4197                                GEN_INT (MIN (arg1_align, arg2_align)));
4198         }
4199 #endif
4200 #ifdef HAVE_cmpstrnsi
4201       /* Try to determine at least one length and call cmpstrnsi.  */
4202       if (!insn && HAVE_cmpstrnsi)
4203         {
4204           tree len;
4205           rtx arg3_rtx;
4206
4207           enum machine_mode insn_mode
4208             = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4209           tree len1 = c_strlen (arg1, 1);
4210           tree len2 = c_strlen (arg2, 1);
4211
4212           if (len1)
4213             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
4214           if (len2)
4215             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
4216
4217           /* If we don't have a constant length for the first, use the length
4218              of the second, if we know it.  We don't require a constant for
4219              this case; some cost analysis could be done if both are available
4220              but neither is constant.  For now, assume they're equally cheap,
4221              unless one has side effects.  If both strings have constant lengths,
4222              use the smaller.  */
4223
4224           if (!len1)
4225             len = len2;
4226           else if (!len2)
4227             len = len1;
4228           else if (TREE_SIDE_EFFECTS (len1))
4229             len = len2;
4230           else if (TREE_SIDE_EFFECTS (len2))
4231             len = len1;
4232           else if (TREE_CODE (len1) != INTEGER_CST)
4233             len = len2;
4234           else if (TREE_CODE (len2) != INTEGER_CST)
4235             len = len1;
4236           else if (tree_int_cst_lt (len1, len2))
4237             len = len1;
4238           else
4239             len = len2;
4240
4241           /* If both arguments have side effects, we cannot optimize.  */
4242           if (!len || TREE_SIDE_EFFECTS (len))
4243             goto do_libcall;
4244
4245           arg3_rtx = expand_normal (len);
4246
4247           /* Make a place to write the result of the instruction.  */
4248           result = target;
4249           if (! (result != 0
4250                  && REG_P (result) && GET_MODE (result) == insn_mode
4251                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4252             result = gen_reg_rtx (insn_mode);
4253
4254           insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4255                                 GEN_INT (MIN (arg1_align, arg2_align)));
4256         }
4257 #endif
4258
4259       if (insn)
4260         {
4261           enum machine_mode mode;
4262           emit_insn (insn);
4263
4264           /* Return the value in the proper mode for this function.  */
4265           mode = TYPE_MODE (TREE_TYPE (exp));
4266           if (GET_MODE (result) == mode)
4267             return result;
4268           if (target == 0)
4269             return convert_to_mode (mode, result, 0);
4270           convert_move (target, result, 0);
4271           return target;
4272         }
4273
4274       /* Expand the library call ourselves using a stabilized argument
4275          list to avoid re-evaluating the function's arguments twice.  */
4276 #ifdef HAVE_cmpstrnsi
4277     do_libcall:
4278 #endif
4279       fndecl = get_callee_fndecl (exp);
4280       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
4281       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4282       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4283       return expand_call (fn, target, target == const0_rtx);
4284     }
4285 #endif
4286   return NULL_RTX;
4287 }
4288
4289 /* Expand expression EXP, which is a call to the strncmp builtin. Return
4290    NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
4291    the result in TARGET, if convenient.  */
4292
4293 static rtx
4294 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
4295                         ATTRIBUTE_UNUSED enum machine_mode mode)
4296 {
4297   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
4298
4299   if (!validate_arglist (exp,
4300                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
4301     return NULL_RTX;
4302
4303   /* If c_strlen can determine an expression for one of the string
4304      lengths, and it doesn't have side effects, then emit cmpstrnsi
4305      using length MIN(strlen(string)+1, arg3).  */
4306 #ifdef HAVE_cmpstrnsi
4307   if (HAVE_cmpstrnsi)
4308   {
4309     tree len, len1, len2;
4310     rtx arg1_rtx, arg2_rtx, arg3_rtx;
4311     rtx result, insn;
4312     tree fndecl, fn;
4313     tree arg1 = CALL_EXPR_ARG (exp, 0);
4314     tree arg2 = CALL_EXPR_ARG (exp, 1);
4315     tree arg3 = CALL_EXPR_ARG (exp, 2);
4316
4317     unsigned int arg1_align
4318       = get_pointer_alignment (arg1, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4319     unsigned int arg2_align
4320       = get_pointer_alignment (arg2, BIGGEST_ALIGNMENT) / BITS_PER_UNIT;
4321     enum machine_mode insn_mode
4322       = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
4323
4324     len1 = c_strlen (arg1, 1);
4325     len2 = c_strlen (arg2, 1);
4326
4327     if (len1)
4328       len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
4329     if (len2)
4330       len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
4331
4332     /* If we don't have a constant length for the first, use the length
4333        of the second, if we know it.  We don't require a constant for
4334        this case; some cost analysis could be done if both are available
4335        but neither is constant.  For now, assume they're equally cheap,
4336        unless one has side effects.  If both strings have constant lengths,
4337        use the smaller.  */
4338
4339     if (!len1)
4340       len = len2;
4341     else if (!len2)
4342       len = len1;
4343     else if (TREE_SIDE_EFFECTS (len1))
4344       len = len2;
4345     else if (TREE_SIDE_EFFECTS (len2))
4346       len = len1;
4347     else if (TREE_CODE (len1) != INTEGER_CST)
4348       len = len2;
4349     else if (TREE_CODE (len2) != INTEGER_CST)
4350       len = len1;
4351     else if (tree_int_cst_lt (len1, len2))
4352       len = len1;
4353     else
4354       len = len2;
4355
4356     /* If both arguments have side effects, we cannot optimize.  */
4357     if (!len || TREE_SIDE_EFFECTS (len))
4358       return NULL_RTX;
4359
4360     /* The actual new length parameter is MIN(len,arg3).  */
4361     len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
4362                        fold_convert_loc (loc, TREE_TYPE (len), arg3));
4363
4364     /* If we don't have POINTER_TYPE, call the function.  */
4365     if (arg1_align == 0 || arg2_align == 0)
4366       return NULL_RTX;
4367
4368     /* Make a place to write the result of the instruction.  */
4369     result = target;
4370     if (! (result != 0
4371            && REG_P (result) && GET_MODE (result) == insn_mode
4372            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
4373       result = gen_reg_rtx (insn_mode);
4374
4375     /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
4376     arg1 = builtin_save_expr (arg1);
4377     arg2 = builtin_save_expr (arg2);
4378     len = builtin_save_expr (len);
4379
4380     arg1_rtx = get_memory_rtx (arg1, len);
4381     arg2_rtx = get_memory_rtx (arg2, len);
4382     arg3_rtx = expand_normal (len);
4383     insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
4384                           GEN_INT (MIN (arg1_align, arg2_align)));
4385     if (insn)
4386       {
4387         emit_insn (insn);
4388
4389         /* Return the value in the proper mode for this function.  */
4390         mode = TYPE_MODE (TREE_TYPE (exp));
4391         if (GET_MODE (result) == mode)
4392           return result;
4393         if (target == 0)
4394           return convert_to_mode (mode, result, 0);
4395         convert_move (target, result, 0);
4396         return target;
4397       }
4398
4399     /* Expand the library call ourselves using a stabilized argument
4400        list to avoid re-evaluating the function's arguments twice.  */
4401     fndecl = get_callee_fndecl (exp);
4402     fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
4403                                 arg1, arg2, len);
4404     gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4405     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4406     return expand_call (fn, target, target == const0_rtx);
4407   }
4408 #endif
4409   return NULL_RTX;
4410 }
4411
4412 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4413    if that's convenient.  */
4414
4415 rtx
4416 expand_builtin_saveregs (void)
4417 {
4418   rtx val, seq;
4419
4420   /* Don't do __builtin_saveregs more than once in a function.
4421      Save the result of the first call and reuse it.  */
4422   if (saveregs_value != 0)
4423     return saveregs_value;
4424
4425   /* When this function is called, it means that registers must be
4426      saved on entry to this function.  So we migrate the call to the
4427      first insn of this function.  */
4428
4429   start_sequence ();
4430
4431   /* Do whatever the machine needs done in this case.  */
4432   val = targetm.calls.expand_builtin_saveregs ();
4433
4434   seq = get_insns ();
4435   end_sequence ();
4436
4437   saveregs_value = val;
4438
4439   /* Put the insns after the NOTE that starts the function.  If this
4440      is inside a start_sequence, make the outer-level insn chain current, so
4441      the code is placed at the start of the function.  */
4442   push_topmost_sequence ();
4443   emit_insn_after (seq, entry_of_function ());
4444   pop_topmost_sequence ();
4445
4446   return val;
4447 }
4448
4449 /* Expand a call to __builtin_next_arg.  */
4450
4451 static rtx
4452 expand_builtin_next_arg (void)
4453 {
4454   /* Checking arguments is already done in fold_builtin_next_arg
4455      that must be called before this function.  */
4456   return expand_binop (ptr_mode, add_optab,
4457                        crtl->args.internal_arg_pointer,
4458                        crtl->args.arg_offset_rtx,
4459                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
4460 }
4461
4462 /* Make it easier for the backends by protecting the valist argument
4463    from multiple evaluations.  */
4464
4465 static tree
4466 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4467 {
4468   tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4469
4470   /* The current way of determining the type of valist is completely
4471      bogus.  We should have the information on the va builtin instead.  */
4472   if (!vatype)
4473     vatype = targetm.fn_abi_va_list (cfun->decl);
4474
4475   if (TREE_CODE (vatype) == ARRAY_TYPE)
4476     {
4477       if (TREE_SIDE_EFFECTS (valist))
4478         valist = save_expr (valist);
4479
4480       /* For this case, the backends will be expecting a pointer to
4481          vatype, but it's possible we've actually been given an array
4482          (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4483          So fix it.  */
4484       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4485         {
4486           tree p1 = build_pointer_type (TREE_TYPE (vatype));
4487           valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4488         }
4489     }
4490   else
4491     {
4492       tree pt = build_pointer_type (vatype);
4493
4494       if (! needs_lvalue)
4495         {
4496           if (! TREE_SIDE_EFFECTS (valist))
4497             return valist;
4498
4499           valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4500           TREE_SIDE_EFFECTS (valist) = 1;
4501         }
4502
4503       if (TREE_SIDE_EFFECTS (valist))
4504         valist = save_expr (valist);
4505       valist = fold_build2_loc (loc, MEM_REF,
4506                                 vatype, valist, build_int_cst (pt, 0));
4507     }
4508
4509   return valist;
4510 }
4511
4512 /* The "standard" definition of va_list is void*.  */
4513
4514 tree
4515 std_build_builtin_va_list (void)
4516 {
4517   return ptr_type_node;
4518 }
4519
4520 /* The "standard" abi va_list is va_list_type_node.  */
4521
4522 tree
4523 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4524 {
4525   return va_list_type_node;
4526 }
4527
4528 /* The "standard" type of va_list is va_list_type_node.  */
4529
4530 tree
4531 std_canonical_va_list_type (tree type)
4532 {
4533   tree wtype, htype;
4534
4535   if (INDIRECT_REF_P (type))
4536     type = TREE_TYPE (type);
4537   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4538     type = TREE_TYPE (type);
4539   wtype = va_list_type_node;
4540   htype = type;
4541   /* Treat structure va_list types.  */
4542   if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4543     htype = TREE_TYPE (htype);
4544   else if (TREE_CODE (wtype) == ARRAY_TYPE)
4545     {
4546       /* If va_list is an array type, the argument may have decayed
4547          to a pointer type, e.g. by being passed to another function.
4548          In that case, unwrap both types so that we can compare the
4549          underlying records.  */
4550       if (TREE_CODE (htype) == ARRAY_TYPE
4551           || POINTER_TYPE_P (htype))
4552         {
4553           wtype = TREE_TYPE (wtype);
4554           htype = TREE_TYPE (htype);
4555         }
4556     }
4557   if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4558     return va_list_type_node;
4559
4560   return NULL_TREE;
4561 }
4562
4563 /* The "standard" implementation of va_start: just assign `nextarg' to
4564    the variable.  */
4565
4566 void
4567 std_expand_builtin_va_start (tree valist, rtx nextarg)
4568 {
4569   rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4570   convert_move (va_r, nextarg, 0);
4571 }
4572
4573 /* Expand EXP, a call to __builtin_va_start.  */
4574
4575 static rtx
4576 expand_builtin_va_start (tree exp)
4577 {
4578   rtx nextarg;
4579   tree valist;
4580   location_t loc = EXPR_LOCATION (exp);
4581
4582   if (call_expr_nargs (exp) < 2)
4583     {
4584       error_at (loc, "too few arguments to function %<va_start%>");
4585       return const0_rtx;
4586     }
4587
4588   if (fold_builtin_next_arg (exp, true))
4589     return const0_rtx;
4590
4591   nextarg = expand_builtin_next_arg ();
4592   valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4593
4594   if (targetm.expand_builtin_va_start)
4595     targetm.expand_builtin_va_start (valist, nextarg);
4596   else
4597     std_expand_builtin_va_start (valist, nextarg);
4598
4599   return const0_rtx;
4600 }
4601
4602 /* The "standard" implementation of va_arg: read the value from the
4603    current (padded) address and increment by the (padded) size.  */
4604
4605 tree
4606 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4607                           gimple_seq *post_p)
4608 {
4609   tree addr, t, type_size, rounded_size, valist_tmp;
4610   unsigned HOST_WIDE_INT align, boundary;
4611   bool indirect;
4612
4613 #ifdef ARGS_GROW_DOWNWARD
4614   /* All of the alignment and movement below is for args-grow-up machines.
4615      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4616      implement their own specialized gimplify_va_arg_expr routines.  */
4617   gcc_unreachable ();
4618 #endif
4619
4620   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4621   if (indirect)
4622     type = build_pointer_type (type);
4623
4624   align = PARM_BOUNDARY / BITS_PER_UNIT;
4625   boundary = FUNCTION_ARG_BOUNDARY (TYPE_MODE (type), type);
4626
4627   /* When we align parameter on stack for caller, if the parameter
4628      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4629      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
4630      here with caller.  */
4631   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4632     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4633
4634   boundary /= BITS_PER_UNIT;
4635
4636   /* Hoist the valist value into a temporary for the moment.  */
4637   valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4638
4639   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
4640      requires greater alignment, we must perform dynamic alignment.  */
4641   if (boundary > align
4642       && !integer_zerop (TYPE_SIZE (type)))
4643     {
4644       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4645                   fold_build2 (POINTER_PLUS_EXPR,
4646                                TREE_TYPE (valist),
4647                                valist_tmp, size_int (boundary - 1)));
4648       gimplify_and_add (t, pre_p);
4649
4650       t = fold_convert (sizetype, valist_tmp);
4651       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4652                   fold_convert (TREE_TYPE (valist),
4653                                 fold_build2 (BIT_AND_EXPR, sizetype, t,
4654                                              size_int (-boundary))));
4655       gimplify_and_add (t, pre_p);
4656     }
4657   else
4658     boundary = align;
4659
4660   /* If the actual alignment is less than the alignment of the type,
4661      adjust the type accordingly so that we don't assume strict alignment
4662      when dereferencing the pointer.  */
4663   boundary *= BITS_PER_UNIT;
4664   if (boundary < TYPE_ALIGN (type))
4665     {
4666       type = build_variant_type_copy (type);
4667       TYPE_ALIGN (type) = boundary;
4668     }
4669
4670   /* Compute the rounded size of the type.  */
4671   type_size = size_in_bytes (type);
4672   rounded_size = round_up (type_size, align);
4673
4674   /* Reduce rounded_size so it's sharable with the postqueue.  */
4675   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4676
4677   /* Get AP.  */
4678   addr = valist_tmp;
4679   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4680     {
4681       /* Small args are padded downward.  */
4682       t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4683                        rounded_size, size_int (align));
4684       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4685                        size_binop (MINUS_EXPR, rounded_size, type_size));
4686       addr = fold_build2 (POINTER_PLUS_EXPR,
4687                           TREE_TYPE (addr), addr, t);
4688     }
4689
4690   /* Compute new value for AP.  */
4691   t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (valist), valist_tmp, rounded_size);
4692   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4693   gimplify_and_add (t, pre_p);
4694
4695   addr = fold_convert (build_pointer_type (type), addr);
4696
4697   if (indirect)
4698     addr = build_va_arg_indirect_ref (addr);
4699
4700   return build_va_arg_indirect_ref (addr);
4701 }
4702
4703 /* Build an indirect-ref expression over the given TREE, which represents a
4704    piece of a va_arg() expansion.  */
4705 tree
4706 build_va_arg_indirect_ref (tree addr)
4707 {
4708   addr = build_fold_indirect_ref_loc (EXPR_LOCATION (addr), addr);
4709
4710   if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF.  */
4711     mf_mark (addr);
4712
4713   return addr;
4714 }
4715
4716 /* Return a dummy expression of type TYPE in order to keep going after an
4717    error.  */
4718
4719 static tree
4720 dummy_object (tree type)
4721 {
4722   tree t = build_int_cst (build_pointer_type (type), 0);
4723   return build2 (MEM_REF, type, t, t);
4724 }
4725
4726 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4727    builtin function, but a very special sort of operator.  */
4728
4729 enum gimplify_status
4730 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4731 {
4732   tree promoted_type, have_va_type;
4733   tree valist = TREE_OPERAND (*expr_p, 0);
4734   tree type = TREE_TYPE (*expr_p);
4735   tree t;
4736   location_t loc = EXPR_LOCATION (*expr_p);
4737
4738   /* Verify that valist is of the proper type.  */
4739   have_va_type = TREE_TYPE (valist);
4740   if (have_va_type == error_mark_node)
4741     return GS_ERROR;
4742   have_va_type = targetm.canonical_va_list_type (have_va_type);
4743
4744   if (have_va_type == NULL_TREE)
4745     {
4746       error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4747       return GS_ERROR;
4748     }
4749
4750   /* Generate a diagnostic for requesting data of a type that cannot
4751      be passed through `...' due to type promotion at the call site.  */
4752   if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4753            != type)
4754     {
4755       static bool gave_help;
4756       bool warned;
4757
4758       /* Unfortunately, this is merely undefined, rather than a constraint
4759          violation, so we cannot make this an error.  If this call is never
4760          executed, the program is still strictly conforming.  */
4761       warned = warning_at (loc, 0,
4762                            "%qT is promoted to %qT when passed through %<...%>",
4763                            type, promoted_type);
4764       if (!gave_help && warned)
4765         {
4766           gave_help = true;
4767           inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4768                   promoted_type, type);
4769         }
4770
4771       /* We can, however, treat "undefined" any way we please.
4772          Call abort to encourage the user to fix the program.  */
4773       if (warned)
4774         inform (loc, "if this code is reached, the program will abort");
4775       /* Before the abort, allow the evaluation of the va_list
4776          expression to exit or longjmp.  */
4777       gimplify_and_add (valist, pre_p);
4778       t = build_call_expr_loc (loc,
4779                                implicit_built_in_decls[BUILT_IN_TRAP], 0);
4780       gimplify_and_add (t, pre_p);
4781
4782       /* This is dead code, but go ahead and finish so that the
4783          mode of the result comes out right.  */
4784       *expr_p = dummy_object (type);
4785       return GS_ALL_DONE;
4786     }
4787   else
4788     {
4789       /* Make it easier for the backends by protecting the valist argument
4790          from multiple evaluations.  */
4791       if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4792         {
4793           /* For this case, the backends will be expecting a pointer to
4794              TREE_TYPE (abi), but it's possible we've
4795              actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4796              So fix it.  */
4797           if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4798             {
4799               tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4800               valist = fold_convert_loc (loc, p1,
4801                                          build_fold_addr_expr_loc (loc, valist));
4802             }
4803
4804           gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4805         }
4806       else
4807         gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4808
4809       if (!targetm.gimplify_va_arg_expr)
4810         /* FIXME: Once most targets are converted we should merely
4811            assert this is non-null.  */
4812         return GS_ALL_DONE;
4813
4814       *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4815       return GS_OK;
4816     }
4817 }
4818
4819 /* Expand EXP, a call to __builtin_va_end.  */
4820
4821 static rtx
4822 expand_builtin_va_end (tree exp)
4823 {
4824   tree valist = CALL_EXPR_ARG (exp, 0);
4825
4826   /* Evaluate for side effects, if needed.  I hate macros that don't
4827      do that.  */
4828   if (TREE_SIDE_EFFECTS (valist))
4829     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4830
4831   return const0_rtx;
4832 }
4833
4834 /* Expand EXP, a call to __builtin_va_copy.  We do this as a
4835    builtin rather than just as an assignment in stdarg.h because of the
4836    nastiness of array-type va_list types.  */
4837
4838 static rtx
4839 expand_builtin_va_copy (tree exp)
4840 {
4841   tree dst, src, t;
4842   location_t loc = EXPR_LOCATION (exp);
4843
4844   dst = CALL_EXPR_ARG (exp, 0);
4845   src = CALL_EXPR_ARG (exp, 1);
4846
4847   dst = stabilize_va_list_loc (loc, dst, 1);
4848   src = stabilize_va_list_loc (loc, src, 0);
4849
4850   gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4851
4852   if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4853     {
4854       t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4855       TREE_SIDE_EFFECTS (t) = 1;
4856       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4857     }
4858   else
4859     {
4860       rtx dstb, srcb, size;
4861
4862       /* Evaluate to pointers.  */
4863       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4864       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4865       size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4866                   NULL_RTX, VOIDmode, EXPAND_NORMAL);
4867
4868       dstb = convert_memory_address (Pmode, dstb);
4869       srcb = convert_memory_address (Pmode, srcb);
4870
4871       /* "Dereference" to BLKmode memories.  */
4872       dstb = gen_rtx_MEM (BLKmode, dstb);
4873       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4874       set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4875       srcb = gen_rtx_MEM (BLKmode, srcb);
4876       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4877       set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4878
4879       /* Copy.  */
4880       emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4881     }
4882
4883   return const0_rtx;
4884 }
4885
4886 /* Expand a call to one of the builtin functions __builtin_frame_address or
4887    __builtin_return_address.  */
4888
4889 static rtx
4890 expand_builtin_frame_address (tree fndecl, tree exp)
4891 {
4892   /* The argument must be a nonnegative integer constant.
4893      It counts the number of frames to scan up the stack.
4894      The value is the return address saved in that frame.  */
4895   if (call_expr_nargs (exp) == 0)
4896     /* Warning about missing arg was already issued.  */
4897     return const0_rtx;
4898   else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4899     {
4900       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4901         error ("invalid argument to %<__builtin_frame_address%>");
4902       else
4903         error ("invalid argument to %<__builtin_return_address%>");
4904       return const0_rtx;
4905     }
4906   else
4907     {
4908       rtx tem
4909         = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4910                                       tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4911
4912       /* Some ports cannot access arbitrary stack frames.  */
4913       if (tem == NULL)
4914         {
4915           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4916             warning (0, "unsupported argument to %<__builtin_frame_address%>");
4917           else
4918             warning (0, "unsupported argument to %<__builtin_return_address%>");
4919           return const0_rtx;
4920         }
4921
4922       /* For __builtin_frame_address, return what we've got.  */
4923       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4924         return tem;
4925
4926       if (!REG_P (tem)
4927           && ! CONSTANT_P (tem))
4928         tem = copy_to_mode_reg (Pmode, tem);
4929       return tem;
4930     }
4931 }
4932
4933 /* Expand EXP, a call to the alloca builtin.  Return NULL_RTX if we
4934    failed and the caller should emit a normal call.  CANNOT_ACCUMULATE
4935    is the same as for allocate_dynamic_stack_space.  */
4936
4937 static rtx
4938 expand_builtin_alloca (tree exp, bool cannot_accumulate)
4939 {
4940   rtx op0;
4941   rtx result;
4942
4943   /* Emit normal call if marked not-inlineable.  */
4944   if (CALL_CANNOT_INLINE_P (exp))
4945     return NULL_RTX;
4946
4947   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4948     return NULL_RTX;
4949
4950   /* Compute the argument.  */
4951   op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4952
4953   /* Allocate the desired space.  */
4954   result = allocate_dynamic_stack_space (op0, 0, BIGGEST_ALIGNMENT,
4955                                          cannot_accumulate);
4956   result = convert_memory_address (ptr_mode, result);
4957
4958   return result;
4959 }
4960
4961 /* Expand a call to a bswap builtin with argument ARG0.  MODE
4962    is the mode to expand with.  */
4963
4964 static rtx
4965 expand_builtin_bswap (tree exp, rtx target, rtx subtarget)
4966 {
4967   enum machine_mode mode;
4968   tree arg;
4969   rtx op0;
4970
4971   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4972     return NULL_RTX;
4973
4974   arg = CALL_EXPR_ARG (exp, 0);
4975   mode = TYPE_MODE (TREE_TYPE (arg));
4976   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4977
4978   target = expand_unop (mode, bswap_optab, op0, target, 1);
4979
4980   gcc_assert (target);
4981
4982   return convert_to_mode (mode, target, 0);
4983 }
4984
4985 /* Expand a call to a unary builtin in EXP.
4986    Return NULL_RTX if a normal call should be emitted rather than expanding the
4987    function in-line.  If convenient, the result should be placed in TARGET.
4988    SUBTARGET may be used as the target for computing one of EXP's operands.  */
4989
4990 static rtx
4991 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
4992                      rtx subtarget, optab op_optab)
4993 {
4994   rtx op0;
4995
4996   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4997     return NULL_RTX;
4998
4999   /* Compute the argument.  */
5000   op0 = expand_expr (CALL_EXPR_ARG (exp, 0),
5001                      (subtarget
5002                       && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0)))
5003                           == GET_MODE (subtarget))) ? subtarget : NULL_RTX,
5004                      VOIDmode, EXPAND_NORMAL);
5005   /* Compute op, into TARGET if possible.
5006      Set TARGET to wherever the result comes back.  */
5007   target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
5008                         op_optab, op0, target, 1);
5009   gcc_assert (target);
5010
5011   return convert_to_mode (target_mode, target, 0);
5012 }
5013
5014 /* Expand a call to __builtin_expect.  We just return our argument
5015    as the builtin_expect semantic should've been already executed by
5016    tree branch prediction pass. */
5017
5018 static rtx
5019 expand_builtin_expect (tree exp, rtx target)
5020 {
5021   tree arg;
5022
5023   if (call_expr_nargs (exp) < 2)
5024     return const0_rtx;
5025   arg = CALL_EXPR_ARG (exp, 0);
5026
5027   target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5028   /* When guessing was done, the hints should be already stripped away.  */
5029   gcc_assert (!flag_guess_branch_prob
5030               || optimize == 0 || seen_error ());
5031   return target;
5032 }
5033
5034 void
5035 expand_builtin_trap (void)
5036 {
5037 #ifdef HAVE_trap
5038   if (HAVE_trap)
5039     emit_insn (gen_trap ());
5040   else
5041 #endif
5042     emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
5043   emit_barrier ();
5044 }
5045
5046 /* Expand a call to __builtin_unreachable.  We do nothing except emit
5047    a barrier saying that control flow will not pass here.
5048
5049    It is the responsibility of the program being compiled to ensure
5050    that control flow does never reach __builtin_unreachable.  */
5051 static void
5052 expand_builtin_unreachable (void)
5053 {
5054   emit_barrier ();
5055 }
5056
5057 /* Expand EXP, a call to fabs, fabsf or fabsl.
5058    Return NULL_RTX if a normal call should be emitted rather than expanding
5059    the function inline.  If convenient, the result should be placed
5060    in TARGET.  SUBTARGET may be used as the target for computing
5061    the operand.  */
5062
5063 static rtx
5064 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
5065 {
5066   enum machine_mode mode;
5067   tree arg;
5068   rtx op0;
5069
5070   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5071     return NULL_RTX;
5072
5073   arg = CALL_EXPR_ARG (exp, 0);
5074   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
5075   mode = TYPE_MODE (TREE_TYPE (arg));
5076   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5077   return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
5078 }
5079
5080 /* Expand EXP, a call to copysign, copysignf, or copysignl.
5081    Return NULL is a normal call should be emitted rather than expanding the
5082    function inline.  If convenient, the result should be placed in TARGET.
5083    SUBTARGET may be used as the target for computing the operand.  */
5084
5085 static rtx
5086 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
5087 {
5088   rtx op0, op1;
5089   tree arg;
5090
5091   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
5092     return NULL_RTX;
5093
5094   arg = CALL_EXPR_ARG (exp, 0);
5095   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
5096
5097   arg = CALL_EXPR_ARG (exp, 1);
5098   op1 = expand_normal (arg);
5099
5100   return expand_copysign (op0, op1, target);
5101 }
5102
5103 /* Create a new constant string literal and return a char* pointer to it.
5104    The STRING_CST value is the LEN characters at STR.  */
5105 tree
5106 build_string_literal (int len, const char *str)
5107 {
5108   tree t, elem, index, type;
5109
5110   t = build_string (len, str);
5111   elem = build_type_variant (char_type_node, 1, 0);
5112   index = build_index_type (size_int (len - 1));
5113   type = build_array_type (elem, index);
5114   TREE_TYPE (t) = type;
5115   TREE_CONSTANT (t) = 1;
5116   TREE_READONLY (t) = 1;
5117   TREE_STATIC (t) = 1;
5118
5119   type = build_pointer_type (elem);
5120   t = build1 (ADDR_EXPR, type,
5121               build4 (ARRAY_REF, elem,
5122                       t, integer_zero_node, NULL_TREE, NULL_TREE));
5123   return t;
5124 }
5125
5126 /* Expand a call to either the entry or exit function profiler.  */
5127
5128 static rtx
5129 expand_builtin_profile_func (bool exitp)
5130 {
5131   rtx this_rtx, which;
5132
5133   this_rtx = DECL_RTL (current_function_decl);
5134   gcc_assert (MEM_P (this_rtx));
5135   this_rtx = XEXP (this_rtx, 0);
5136
5137   if (exitp)
5138     which = profile_function_exit_libfunc;
5139   else
5140     which = profile_function_entry_libfunc;
5141
5142   emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this_rtx, Pmode,
5143                      expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
5144                                                  0),
5145                      Pmode);
5146
5147   return const0_rtx;
5148 }
5149
5150 /* Expand a call to __builtin___clear_cache.  */
5151
5152 static rtx
5153 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
5154 {
5155 #ifndef HAVE_clear_cache
5156 #ifdef CLEAR_INSN_CACHE
5157   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5158      does something.  Just do the default expansion to a call to
5159      __clear_cache().  */
5160   return NULL_RTX;
5161 #else
5162   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
5163      does nothing.  There is no need to call it.  Do nothing.  */
5164   return const0_rtx;
5165 #endif /* CLEAR_INSN_CACHE */
5166 #else
5167   /* We have a "clear_cache" insn, and it will handle everything.  */
5168   tree begin, end;
5169   rtx begin_rtx, end_rtx;
5170   enum insn_code icode;
5171
5172   /* We must not expand to a library call.  If we did, any
5173      fallback library function in libgcc that might contain a call to
5174      __builtin___clear_cache() would recurse infinitely.  */
5175   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
5176     {
5177       error ("both arguments to %<__builtin___clear_cache%> must be pointers");
5178       return const0_rtx;
5179     }
5180
5181   if (HAVE_clear_cache)
5182     {
5183       icode = CODE_FOR_clear_cache;
5184
5185       begin = CALL_EXPR_ARG (exp, 0);
5186       begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
5187       begin_rtx = convert_memory_address (Pmode, begin_rtx);
5188       if (!insn_data[icode].operand[0].predicate (begin_rtx, Pmode))
5189         begin_rtx = copy_to_mode_reg (Pmode, begin_rtx);
5190
5191       end = CALL_EXPR_ARG (exp, 1);
5192       end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
5193       end_rtx = convert_memory_address (Pmode, end_rtx);
5194       if (!insn_data[icode].operand[1].predicate (end_rtx, Pmode))
5195         end_rtx = copy_to_mode_reg (Pmode, end_rtx);
5196
5197       emit_insn (gen_clear_cache (begin_rtx, end_rtx));
5198     }
5199   return const0_rtx;
5200 #endif /* HAVE_clear_cache */
5201 }
5202
5203 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT.  */
5204
5205 static rtx
5206 round_trampoline_addr (rtx tramp)
5207 {
5208   rtx temp, addend, mask;
5209
5210   /* If we don't need too much alignment, we'll have been guaranteed
5211      proper alignment by get_trampoline_type.  */
5212   if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
5213     return tramp;
5214
5215   /* Round address up to desired boundary.  */
5216   temp = gen_reg_rtx (Pmode);
5217   addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
5218   mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
5219
5220   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
5221                                temp, 0, OPTAB_LIB_WIDEN);
5222   tramp = expand_simple_binop (Pmode, AND, temp, mask,
5223                                temp, 0, OPTAB_LIB_WIDEN);
5224
5225   return tramp;
5226 }
5227
5228 static rtx
5229 expand_builtin_init_trampoline (tree exp)
5230 {
5231   tree t_tramp, t_func, t_chain;
5232   rtx m_tramp, r_tramp, r_chain, tmp;
5233
5234   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
5235                          POINTER_TYPE, VOID_TYPE))
5236     return NULL_RTX;
5237
5238   t_tramp = CALL_EXPR_ARG (exp, 0);
5239   t_func = CALL_EXPR_ARG (exp, 1);
5240   t_chain = CALL_EXPR_ARG (exp, 2);
5241
5242   r_tramp = expand_normal (t_tramp);
5243   m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
5244   MEM_NOTRAP_P (m_tramp) = 1;
5245
5246   /* The TRAMP argument should be the address of a field within the
5247      local function's FRAME decl.  Let's see if we can fill in the
5248      to fill in the MEM_ATTRs for this memory.  */
5249   if (TREE_CODE (t_tramp) == ADDR_EXPR)
5250     set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
5251                                      true, 0);
5252
5253   tmp = round_trampoline_addr (r_tramp);
5254   if (tmp != r_tramp)
5255     {
5256       m_tramp = change_address (m_tramp, BLKmode, tmp);
5257       set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
5258       set_mem_size (m_tramp, GEN_INT (TRAMPOLINE_SIZE));
5259     }
5260
5261   /* The FUNC argument should be the address of the nested function.
5262      Extract the actual function decl to pass to the hook.  */
5263   gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
5264   t_func = TREE_OPERAND (t_func, 0);
5265   gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
5266
5267   r_chain = expand_normal (t_chain);
5268
5269   /* Generate insns to initialize the trampoline.  */
5270   targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
5271
5272   trampolines_created = 1;
5273
5274   warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
5275               "trampoline generated for nested function %qD", t_func);
5276
5277   return const0_rtx;
5278 }
5279
5280 static rtx
5281 expand_builtin_adjust_trampoline (tree exp)
5282 {
5283   rtx tramp;
5284
5285   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5286     return NULL_RTX;
5287
5288   tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
5289   tramp = round_trampoline_addr (tramp);
5290   if (targetm.calls.trampoline_adjust_address)
5291     tramp = targetm.calls.trampoline_adjust_address (tramp);
5292
5293   return tramp;
5294 }
5295
5296 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
5297    function.  The function first checks whether the back end provides
5298    an insn to implement signbit for the respective mode.  If not, it
5299    checks whether the floating point format of the value is such that
5300    the sign bit can be extracted.  If that is not the case, the
5301    function returns NULL_RTX to indicate that a normal call should be
5302    emitted rather than expanding the function in-line.  EXP is the
5303    expression that is a call to the builtin function; if convenient,
5304    the result should be placed in TARGET.  */
5305 static rtx
5306 expand_builtin_signbit (tree exp, rtx target)
5307 {
5308   const struct real_format *fmt;
5309   enum machine_mode fmode, imode, rmode;
5310   tree arg;
5311   int word, bitpos;
5312   enum insn_code icode;
5313   rtx temp;
5314   location_t loc = EXPR_LOCATION (exp);
5315
5316   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
5317     return NULL_RTX;
5318
5319   arg = CALL_EXPR_ARG (exp, 0);
5320   fmode = TYPE_MODE (TREE_TYPE (arg));
5321   rmode = TYPE_MODE (TREE_TYPE (exp));
5322   fmt = REAL_MODE_FORMAT (fmode);
5323
5324   arg = builtin_save_expr (arg);
5325
5326   /* Expand the argument yielding a RTX expression. */
5327   temp = expand_normal (arg);
5328
5329   /* Check if the back end provides an insn that handles signbit for the
5330      argument's mode. */
5331   icode = optab_handler (signbit_optab, fmode);
5332   if (icode != CODE_FOR_nothing)
5333     {
5334       rtx last = get_last_insn ();
5335       target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
5336       if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
5337         return target;
5338       delete_insns_since (last);
5339     }
5340
5341   /* For floating point formats without a sign bit, implement signbit
5342      as "ARG < 0.0".  */
5343   bitpos = fmt->signbit_ro;
5344   if (bitpos < 0)
5345   {
5346     /* But we can't do this if the format supports signed zero.  */
5347     if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
5348       return NULL_RTX;
5349
5350     arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
5351                        build_real (TREE_TYPE (arg), dconst0));
5352     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
5353   }
5354
5355   if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
5356     {
5357       imode = int_mode_for_mode (fmode);
5358       if (imode == BLKmode)
5359         return NULL_RTX;
5360       temp = gen_lowpart (imode, temp);
5361     }
5362   else
5363     {
5364       imode = word_mode;
5365       /* Handle targets with different FP word orders.  */
5366       if (FLOAT_WORDS_BIG_ENDIAN)
5367         word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
5368       else
5369         word = bitpos / BITS_PER_WORD;
5370       temp = operand_subword_force (temp, word, fmode);
5371       bitpos = bitpos % BITS_PER_WORD;
5372     }
5373
5374   /* Force the intermediate word_mode (or narrower) result into a
5375      register.  This avoids attempting to create paradoxical SUBREGs
5376      of floating point modes below.  */
5377   temp = force_reg (imode, temp);
5378
5379   /* If the bitpos is within the "result mode" lowpart, the operation
5380      can be implement with a single bitwise AND.  Otherwise, we need
5381      a right shift and an AND.  */
5382
5383   if (bitpos < GET_MODE_BITSIZE (rmode))
5384     {
5385       double_int mask = double_int_setbit (double_int_zero, bitpos);
5386
5387       if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
5388         temp = gen_lowpart (rmode, temp);
5389       temp = expand_binop (rmode, and_optab, temp,
5390                            immed_double_int_const (mask, rmode),
5391                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5392     }
5393   else
5394     {
5395       /* Perform a logical right shift to place the signbit in the least
5396          significant bit, then truncate the result to the desired mode
5397          and mask just this bit.  */
5398       temp = expand_shift (RSHIFT_EXPR, imode, temp,
5399                            build_int_cst (NULL_TREE, bitpos), NULL_RTX, 1);
5400       temp = gen_lowpart (rmode, temp);
5401       temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5402                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5403     }
5404
5405   return temp;
5406 }
5407
5408 /* Expand fork or exec calls.  TARGET is the desired target of the
5409    call.  EXP is the call. FN is the
5410    identificator of the actual function.  IGNORE is nonzero if the
5411    value is to be ignored.  */
5412
5413 static rtx
5414 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5415 {
5416   tree id, decl;
5417   tree call;
5418
5419   /* If we are not profiling, just call the function.  */
5420   if (!profile_arc_flag)
5421     return NULL_RTX;
5422
5423   /* Otherwise call the wrapper.  This should be equivalent for the rest of
5424      compiler, so the code does not diverge, and the wrapper may run the
5425      code necessary for keeping the profiling sane.  */
5426
5427   switch (DECL_FUNCTION_CODE (fn))
5428     {
5429     case BUILT_IN_FORK:
5430       id = get_identifier ("__gcov_fork");
5431       break;
5432
5433     case BUILT_IN_EXECL:
5434       id = get_identifier ("__gcov_execl");
5435       break;
5436
5437     case BUILT_IN_EXECV:
5438       id = get_identifier ("__gcov_execv");
5439       break;
5440
5441     case BUILT_IN_EXECLP:
5442       id = get_identifier ("__gcov_execlp");
5443       break;
5444
5445     case BUILT_IN_EXECLE:
5446       id = get_identifier ("__gcov_execle");
5447       break;
5448
5449     case BUILT_IN_EXECVP:
5450       id = get_identifier ("__gcov_execvp");
5451       break;
5452
5453     case BUILT_IN_EXECVE:
5454       id = get_identifier ("__gcov_execve");
5455       break;
5456
5457     default:
5458       gcc_unreachable ();
5459     }
5460
5461   decl = build_decl (DECL_SOURCE_LOCATION (fn),
5462                      FUNCTION_DECL, id, TREE_TYPE (fn));
5463   DECL_EXTERNAL (decl) = 1;
5464   TREE_PUBLIC (decl) = 1;
5465   DECL_ARTIFICIAL (decl) = 1;
5466   TREE_NOTHROW (decl) = 1;
5467   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5468   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5469   call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5470   return expand_call (call, target, ignore);
5471  }
5472
5473
5474 \f
5475 /* Reconstitute a mode for a __sync intrinsic operation.  Since the type of
5476    the pointer in these functions is void*, the tree optimizers may remove
5477    casts.  The mode computed in expand_builtin isn't reliable either, due
5478    to __sync_bool_compare_and_swap.
5479
5480    FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5481    group of builtins.  This gives us log2 of the mode size.  */
5482
5483 static inline enum machine_mode
5484 get_builtin_sync_mode (int fcode_diff)
5485 {
5486   /* The size is not negotiable, so ask not to get BLKmode in return
5487      if the target indicates that a smaller size would be better.  */
5488   return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5489 }
5490
5491 /* Expand the memory expression LOC and return the appropriate memory operand
5492    for the builtin_sync operations.  */
5493
5494 static rtx
5495 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5496 {
5497   rtx addr, mem;
5498
5499   addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
5500   addr = convert_memory_address (Pmode, addr);
5501
5502   /* Note that we explicitly do not want any alias information for this
5503      memory, so that we kill all other live memories.  Otherwise we don't
5504      satisfy the full barrier semantics of the intrinsic.  */
5505   mem = validize_mem (gen_rtx_MEM (mode, addr));
5506
5507   /* The alignment needs to be at least according to that of the mode.  */
5508   set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
5509                            get_pointer_alignment (loc, BIGGEST_ALIGNMENT)));
5510   set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5511   MEM_VOLATILE_P (mem) = 1;
5512
5513   return mem;
5514 }
5515
5516 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5517    EXP is the CALL_EXPR.  CODE is the rtx code
5518    that corresponds to the arithmetic or logical operation from the name;
5519    an exception here is that NOT actually means NAND.  TARGET is an optional
5520    place for us to store the results; AFTER is true if this is the
5521    fetch_and_xxx form.  IGNORE is true if we don't actually care about
5522    the result of the operation at all.  */
5523
5524 static rtx
5525 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5526                                enum rtx_code code, bool after,
5527                                rtx target, bool ignore)
5528 {
5529   rtx val, mem;
5530   enum machine_mode old_mode;
5531   location_t loc = EXPR_LOCATION (exp);
5532
5533   if (code == NOT && warn_sync_nand)
5534     {
5535       tree fndecl = get_callee_fndecl (exp);
5536       enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5537
5538       static bool warned_f_a_n, warned_n_a_f;
5539
5540       switch (fcode)
5541         {
5542         case BUILT_IN_FETCH_AND_NAND_1:
5543         case BUILT_IN_FETCH_AND_NAND_2:
5544         case BUILT_IN_FETCH_AND_NAND_4:
5545         case BUILT_IN_FETCH_AND_NAND_8:
5546         case BUILT_IN_FETCH_AND_NAND_16:
5547
5548           if (warned_f_a_n)
5549             break;
5550
5551           fndecl = implicit_built_in_decls[BUILT_IN_FETCH_AND_NAND_N];
5552           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5553           warned_f_a_n = true;
5554           break;
5555
5556         case BUILT_IN_NAND_AND_FETCH_1:
5557         case BUILT_IN_NAND_AND_FETCH_2:
5558         case BUILT_IN_NAND_AND_FETCH_4:
5559         case BUILT_IN_NAND_AND_FETCH_8:
5560         case BUILT_IN_NAND_AND_FETCH_16:
5561
5562           if (warned_n_a_f)
5563             break;
5564
5565           fndecl = implicit_built_in_decls[BUILT_IN_NAND_AND_FETCH_N];
5566           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5567           warned_n_a_f = true;
5568           break;
5569
5570         default:
5571           gcc_unreachable ();
5572         }
5573     }
5574
5575   /* Expand the operands.  */
5576   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5577
5578   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5579   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5580      of CONST_INTs, where we know the old_mode only from the call argument.  */
5581   old_mode = GET_MODE (val);
5582   if (old_mode == VOIDmode)
5583     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5584   val = convert_modes (mode, old_mode, val, 1);
5585
5586   if (ignore)
5587     return expand_sync_operation (mem, val, code);
5588   else
5589     return expand_sync_fetch_operation (mem, val, code, after, target);
5590 }
5591
5592 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5593    intrinsics. EXP is the CALL_EXPR.  IS_BOOL is
5594    true if this is the boolean form.  TARGET is a place for us to store the
5595    results; this is NOT optional if IS_BOOL is true.  */
5596
5597 static rtx
5598 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5599                                  bool is_bool, rtx target)
5600 {
5601   rtx old_val, new_val, mem;
5602   enum machine_mode old_mode;
5603
5604   /* Expand the operands.  */
5605   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5606
5607
5608   old_val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX,
5609                          mode, EXPAND_NORMAL);
5610   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5611      of CONST_INTs, where we know the old_mode only from the call argument.  */
5612   old_mode = GET_MODE (old_val);
5613   if (old_mode == VOIDmode)
5614     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5615   old_val = convert_modes (mode, old_mode, old_val, 1);
5616
5617   new_val = expand_expr (CALL_EXPR_ARG (exp, 2), NULL_RTX,
5618                          mode, EXPAND_NORMAL);
5619   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5620      of CONST_INTs, where we know the old_mode only from the call argument.  */
5621   old_mode = GET_MODE (new_val);
5622   if (old_mode == VOIDmode)
5623     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 2)));
5624   new_val = convert_modes (mode, old_mode, new_val, 1);
5625
5626   if (is_bool)
5627     return expand_bool_compare_and_swap (mem, old_val, new_val, target);
5628   else
5629     return expand_val_compare_and_swap (mem, old_val, new_val, target);
5630 }
5631
5632 /* Expand the __sync_lock_test_and_set intrinsic.  Note that the most
5633    general form is actually an atomic exchange, and some targets only
5634    support a reduced form with the second argument being a constant 1.
5635    EXP is the CALL_EXPR; TARGET is an optional place for us to store
5636    the results.  */
5637
5638 static rtx
5639 expand_builtin_lock_test_and_set (enum machine_mode mode, tree exp,
5640                                   rtx target)
5641 {
5642   rtx val, mem;
5643   enum machine_mode old_mode;
5644
5645   /* Expand the operands.  */
5646   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5647   val = expand_expr (CALL_EXPR_ARG (exp, 1), NULL_RTX, mode, EXPAND_NORMAL);
5648   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5649      of CONST_INTs, where we know the old_mode only from the call argument.  */
5650   old_mode = GET_MODE (val);
5651   if (old_mode == VOIDmode)
5652     old_mode = TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 1)));
5653   val = convert_modes (mode, old_mode, val, 1);
5654
5655   return expand_sync_lock_test_and_set (mem, val, target);
5656 }
5657
5658 /* Expand the __sync_synchronize intrinsic.  */
5659
5660 static void
5661 expand_builtin_synchronize (void)
5662 {
5663   gimple x;
5664   VEC (tree, gc) *v_clobbers;
5665
5666 #ifdef HAVE_memory_barrier
5667   if (HAVE_memory_barrier)
5668     {
5669       emit_insn (gen_memory_barrier ());
5670       return;
5671     }
5672 #endif
5673
5674   if (synchronize_libfunc != NULL_RTX)
5675     {
5676       emit_library_call (synchronize_libfunc, LCT_NORMAL, VOIDmode, 0);
5677       return;
5678     }
5679
5680   /* If no explicit memory barrier instruction is available, create an
5681      empty asm stmt with a memory clobber.  */
5682   v_clobbers = VEC_alloc (tree, gc, 1);
5683   VEC_quick_push (tree, v_clobbers,
5684                   tree_cons (NULL, build_string (6, "memory"), NULL));
5685   x = gimple_build_asm_vec ("", NULL, NULL, v_clobbers, NULL);
5686   gimple_asm_set_volatile (x, true);
5687   expand_asm_stmt (x);
5688 }
5689
5690 /* Expand the __sync_lock_release intrinsic.  EXP is the CALL_EXPR.  */
5691
5692 static void
5693 expand_builtin_lock_release (enum machine_mode mode, tree exp)
5694 {
5695   enum insn_code icode;
5696   rtx mem, insn;
5697   rtx val = const0_rtx;
5698
5699   /* Expand the operands.  */
5700   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5701
5702   /* If there is an explicit operation in the md file, use it.  */
5703   icode = direct_optab_handler (sync_lock_release_optab, mode);
5704   if (icode != CODE_FOR_nothing)
5705     {
5706       if (!insn_data[icode].operand[1].predicate (val, mode))
5707         val = force_reg (mode, val);
5708
5709       insn = GEN_FCN (icode) (mem, val);
5710       if (insn)
5711         {
5712           emit_insn (insn);
5713           return;
5714         }
5715     }
5716
5717   /* Otherwise we can implement this operation by emitting a barrier
5718      followed by a store of zero.  */
5719   expand_builtin_synchronize ();
5720   emit_move_insn (mem, val);
5721 }
5722 \f
5723 /* Expand an expression EXP that calls a built-in function,
5724    with result going to TARGET if that's convenient
5725    (and in mode MODE if that's convenient).
5726    SUBTARGET may be used as the target for computing one of EXP's operands.
5727    IGNORE is nonzero if the value is to be ignored.  */
5728
5729 rtx
5730 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5731                 int ignore)
5732 {
5733   tree fndecl = get_callee_fndecl (exp);
5734   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5735   enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5736   int flags;
5737
5738   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5739     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5740
5741   /* When not optimizing, generate calls to library functions for a certain
5742      set of builtins.  */
5743   if (!optimize
5744       && !called_as_built_in (fndecl)
5745       && DECL_ASSEMBLER_NAME_SET_P (fndecl)
5746       && fcode != BUILT_IN_ALLOCA
5747       && fcode != BUILT_IN_FREE)
5748     return expand_call (exp, target, ignore);
5749
5750   /* The built-in function expanders test for target == const0_rtx
5751      to determine whether the function's result will be ignored.  */
5752   if (ignore)
5753     target = const0_rtx;
5754
5755   /* If the result of a pure or const built-in function is ignored, and
5756      none of its arguments are volatile, we can avoid expanding the
5757      built-in call and just evaluate the arguments for side-effects.  */
5758   if (target == const0_rtx
5759       && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5760       && !(flags & ECF_LOOPING_CONST_OR_PURE))
5761     {
5762       bool volatilep = false;
5763       tree arg;
5764       call_expr_arg_iterator iter;
5765
5766       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5767         if (TREE_THIS_VOLATILE (arg))
5768           {
5769             volatilep = true;
5770             break;
5771           }
5772
5773       if (! volatilep)
5774         {
5775           FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5776             expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5777           return const0_rtx;
5778         }
5779     }
5780
5781   switch (fcode)
5782     {
5783     CASE_FLT_FN (BUILT_IN_FABS):
5784       target = expand_builtin_fabs (exp, target, subtarget);
5785       if (target)
5786         return target;
5787       break;
5788
5789     CASE_FLT_FN (BUILT_IN_COPYSIGN):
5790       target = expand_builtin_copysign (exp, target, subtarget);
5791       if (target)
5792         return target;
5793       break;
5794
5795       /* Just do a normal library call if we were unable to fold
5796          the values.  */
5797     CASE_FLT_FN (BUILT_IN_CABS):
5798       break;
5799
5800     CASE_FLT_FN (BUILT_IN_EXP):
5801     CASE_FLT_FN (BUILT_IN_EXP10):
5802     CASE_FLT_FN (BUILT_IN_POW10):
5803     CASE_FLT_FN (BUILT_IN_EXP2):
5804     CASE_FLT_FN (BUILT_IN_EXPM1):
5805     CASE_FLT_FN (BUILT_IN_LOGB):
5806     CASE_FLT_FN (BUILT_IN_LOG):
5807     CASE_FLT_FN (BUILT_IN_LOG10):
5808     CASE_FLT_FN (BUILT_IN_LOG2):
5809     CASE_FLT_FN (BUILT_IN_LOG1P):
5810     CASE_FLT_FN (BUILT_IN_TAN):
5811     CASE_FLT_FN (BUILT_IN_ASIN):
5812     CASE_FLT_FN (BUILT_IN_ACOS):
5813     CASE_FLT_FN (BUILT_IN_ATAN):
5814     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5815       /* Treat these like sqrt only if unsafe math optimizations are allowed,
5816          because of possible accuracy problems.  */
5817       if (! flag_unsafe_math_optimizations)
5818         break;
5819     CASE_FLT_FN (BUILT_IN_SQRT):
5820     CASE_FLT_FN (BUILT_IN_FLOOR):
5821     CASE_FLT_FN (BUILT_IN_CEIL):
5822     CASE_FLT_FN (BUILT_IN_TRUNC):
5823     CASE_FLT_FN (BUILT_IN_ROUND):
5824     CASE_FLT_FN (BUILT_IN_NEARBYINT):
5825     CASE_FLT_FN (BUILT_IN_RINT):
5826       target = expand_builtin_mathfn (exp, target, subtarget);
5827       if (target)
5828         return target;
5829       break;
5830
5831     CASE_FLT_FN (BUILT_IN_ILOGB):
5832       if (! flag_unsafe_math_optimizations)
5833         break;
5834     CASE_FLT_FN (BUILT_IN_ISINF):
5835     CASE_FLT_FN (BUILT_IN_FINITE):
5836     case BUILT_IN_ISFINITE:
5837     case BUILT_IN_ISNORMAL:
5838       target = expand_builtin_interclass_mathfn (exp, target);
5839       if (target)
5840         return target;
5841       break;
5842
5843     CASE_FLT_FN (BUILT_IN_LCEIL):
5844     CASE_FLT_FN (BUILT_IN_LLCEIL):
5845     CASE_FLT_FN (BUILT_IN_LFLOOR):
5846     CASE_FLT_FN (BUILT_IN_LLFLOOR):
5847       target = expand_builtin_int_roundingfn (exp, target);
5848       if (target)
5849         return target;
5850       break;
5851
5852     CASE_FLT_FN (BUILT_IN_LRINT):
5853     CASE_FLT_FN (BUILT_IN_LLRINT):
5854     CASE_FLT_FN (BUILT_IN_LROUND):
5855     CASE_FLT_FN (BUILT_IN_LLROUND):
5856       target = expand_builtin_int_roundingfn_2 (exp, target);
5857       if (target)
5858         return target;
5859       break;
5860
5861     CASE_FLT_FN (BUILT_IN_POW):
5862       target = expand_builtin_pow (exp, target, subtarget);
5863       if (target)
5864         return target;
5865       break;
5866
5867     CASE_FLT_FN (BUILT_IN_POWI):
5868       target = expand_builtin_powi (exp, target);
5869       if (target)
5870         return target;
5871       break;
5872
5873     CASE_FLT_FN (BUILT_IN_ATAN2):
5874     CASE_FLT_FN (BUILT_IN_LDEXP):
5875     CASE_FLT_FN (BUILT_IN_SCALB):
5876     CASE_FLT_FN (BUILT_IN_SCALBN):
5877     CASE_FLT_FN (BUILT_IN_SCALBLN):
5878       if (! flag_unsafe_math_optimizations)
5879         break;
5880
5881     CASE_FLT_FN (BUILT_IN_FMOD):
5882     CASE_FLT_FN (BUILT_IN_REMAINDER):
5883     CASE_FLT_FN (BUILT_IN_DREM):
5884       target = expand_builtin_mathfn_2 (exp, target, subtarget);
5885       if (target)
5886         return target;
5887       break;
5888
5889     CASE_FLT_FN (BUILT_IN_CEXPI):
5890       target = expand_builtin_cexpi (exp, target);
5891       gcc_assert (target);
5892       return target;
5893
5894     CASE_FLT_FN (BUILT_IN_SIN):
5895     CASE_FLT_FN (BUILT_IN_COS):
5896       if (! flag_unsafe_math_optimizations)
5897         break;
5898       target = expand_builtin_mathfn_3 (exp, target, subtarget);
5899       if (target)
5900         return target;
5901       break;
5902
5903     CASE_FLT_FN (BUILT_IN_SINCOS):
5904       if (! flag_unsafe_math_optimizations)
5905         break;
5906       target = expand_builtin_sincos (exp);
5907       if (target)
5908         return target;
5909       break;
5910
5911     case BUILT_IN_APPLY_ARGS:
5912       return expand_builtin_apply_args ();
5913
5914       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5915          FUNCTION with a copy of the parameters described by
5916          ARGUMENTS, and ARGSIZE.  It returns a block of memory
5917          allocated on the stack into which is stored all the registers
5918          that might possibly be used for returning the result of a
5919          function.  ARGUMENTS is the value returned by
5920          __builtin_apply_args.  ARGSIZE is the number of bytes of
5921          arguments that must be copied.  ??? How should this value be
5922          computed?  We'll also need a safe worst case value for varargs
5923          functions.  */
5924     case BUILT_IN_APPLY:
5925       if (!validate_arglist (exp, POINTER_TYPE,
5926                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5927           && !validate_arglist (exp, REFERENCE_TYPE,
5928                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5929         return const0_rtx;
5930       else
5931         {
5932           rtx ops[3];
5933
5934           ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
5935           ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
5936           ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
5937
5938           return expand_builtin_apply (ops[0], ops[1], ops[2]);
5939         }
5940
5941       /* __builtin_return (RESULT) causes the function to return the
5942          value described by RESULT.  RESULT is address of the block of
5943          memory returned by __builtin_apply.  */
5944     case BUILT_IN_RETURN:
5945       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5946         expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
5947       return const0_rtx;
5948
5949     case BUILT_IN_SAVEREGS:
5950       return expand_builtin_saveregs ();
5951
5952     case BUILT_IN_VA_ARG_PACK:
5953       /* All valid uses of __builtin_va_arg_pack () are removed during
5954          inlining.  */
5955       error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
5956       return const0_rtx;
5957
5958     case BUILT_IN_VA_ARG_PACK_LEN:
5959       /* All valid uses of __builtin_va_arg_pack_len () are removed during
5960          inlining.  */
5961       error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
5962       return const0_rtx;
5963
5964       /* Return the address of the first anonymous stack arg.  */
5965     case BUILT_IN_NEXT_ARG:
5966       if (fold_builtin_next_arg (exp, false))
5967         return const0_rtx;
5968       return expand_builtin_next_arg ();
5969
5970     case BUILT_IN_CLEAR_CACHE:
5971       target = expand_builtin___clear_cache (exp);
5972       if (target)
5973         return target;
5974       break;
5975
5976     case BUILT_IN_CLASSIFY_TYPE:
5977       return expand_builtin_classify_type (exp);
5978
5979     case BUILT_IN_CONSTANT_P:
5980       return const0_rtx;
5981
5982     case BUILT_IN_FRAME_ADDRESS:
5983     case BUILT_IN_RETURN_ADDRESS:
5984       return expand_builtin_frame_address (fndecl, exp);
5985
5986     /* Returns the address of the area where the structure is returned.
5987        0 otherwise.  */
5988     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
5989       if (call_expr_nargs (exp) != 0
5990           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
5991           || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
5992         return const0_rtx;
5993       else
5994         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
5995
5996     case BUILT_IN_ALLOCA:
5997       /* If the allocation stems from the declaration of a variable-sized
5998          object, it cannot accumulate.  */
5999       target = expand_builtin_alloca (exp, ALLOCA_FOR_VAR_P (exp));
6000       if (target)
6001         return target;
6002       break;
6003
6004     case BUILT_IN_STACK_SAVE:
6005       return expand_stack_save ();
6006
6007     case BUILT_IN_STACK_RESTORE:
6008       expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6009       return const0_rtx;
6010
6011     case BUILT_IN_BSWAP32:
6012     case BUILT_IN_BSWAP64:
6013       target = expand_builtin_bswap (exp, target, subtarget);
6014
6015       if (target)
6016         return target;
6017       break;
6018
6019     CASE_INT_FN (BUILT_IN_FFS):
6020     case BUILT_IN_FFSIMAX:
6021       target = expand_builtin_unop (target_mode, exp, target,
6022                                     subtarget, ffs_optab);
6023       if (target)
6024         return target;
6025       break;
6026
6027     CASE_INT_FN (BUILT_IN_CLZ):
6028     case BUILT_IN_CLZIMAX:
6029       target = expand_builtin_unop (target_mode, exp, target,
6030                                     subtarget, clz_optab);
6031       if (target)
6032         return target;
6033       break;
6034
6035     CASE_INT_FN (BUILT_IN_CTZ):
6036     case BUILT_IN_CTZIMAX:
6037       target = expand_builtin_unop (target_mode, exp, target,
6038                                     subtarget, ctz_optab);
6039       if (target)
6040         return target;
6041       break;
6042
6043     CASE_INT_FN (BUILT_IN_POPCOUNT):
6044     case BUILT_IN_POPCOUNTIMAX:
6045       target = expand_builtin_unop (target_mode, exp, target,
6046                                     subtarget, popcount_optab);
6047       if (target)
6048         return target;
6049       break;
6050
6051     CASE_INT_FN (BUILT_IN_PARITY):
6052     case BUILT_IN_PARITYIMAX:
6053       target = expand_builtin_unop (target_mode, exp, target,
6054                                     subtarget, parity_optab);
6055       if (target)
6056         return target;
6057       break;
6058
6059     case BUILT_IN_STRLEN:
6060       target = expand_builtin_strlen (exp, target, target_mode);
6061       if (target)
6062         return target;
6063       break;
6064
6065     case BUILT_IN_STRCPY:
6066       target = expand_builtin_strcpy (exp, target);
6067       if (target)
6068         return target;
6069       break;
6070
6071     case BUILT_IN_STRNCPY:
6072       target = expand_builtin_strncpy (exp, target);
6073       if (target)
6074         return target;
6075       break;
6076
6077     case BUILT_IN_STPCPY:
6078       target = expand_builtin_stpcpy (exp, target, mode);
6079       if (target)
6080         return target;
6081       break;
6082
6083     case BUILT_IN_MEMCPY:
6084       target = expand_builtin_memcpy (exp, target);
6085       if (target)
6086         return target;
6087       break;
6088
6089     case BUILT_IN_MEMPCPY:
6090       target = expand_builtin_mempcpy (exp, target, mode);
6091       if (target)
6092         return target;
6093       break;
6094
6095     case BUILT_IN_MEMSET:
6096       target = expand_builtin_memset (exp, target, mode);
6097       if (target)
6098         return target;
6099       break;
6100
6101     case BUILT_IN_BZERO:
6102       target = expand_builtin_bzero (exp);
6103       if (target)
6104         return target;
6105       break;
6106
6107     case BUILT_IN_STRCMP:
6108       target = expand_builtin_strcmp (exp, target);
6109       if (target)
6110         return target;
6111       break;
6112
6113     case BUILT_IN_STRNCMP:
6114       target = expand_builtin_strncmp (exp, target, mode);
6115       if (target)
6116         return target;
6117       break;
6118
6119     case BUILT_IN_BCMP:
6120     case BUILT_IN_MEMCMP:
6121       target = expand_builtin_memcmp (exp, target, mode);
6122       if (target)
6123         return target;
6124       break;
6125
6126     case BUILT_IN_SETJMP:
6127       /* This should have been lowered to the builtins below.  */
6128       gcc_unreachable ();
6129
6130     case BUILT_IN_SETJMP_SETUP:
6131       /* __builtin_setjmp_setup is passed a pointer to an array of five words
6132           and the receiver label.  */
6133       if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6134         {
6135           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6136                                       VOIDmode, EXPAND_NORMAL);
6137           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6138           rtx label_r = label_rtx (label);
6139
6140           /* This is copied from the handling of non-local gotos.  */
6141           expand_builtin_setjmp_setup (buf_addr, label_r);
6142           nonlocal_goto_handler_labels
6143             = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6144                                  nonlocal_goto_handler_labels);
6145           /* ??? Do not let expand_label treat us as such since we would
6146              not want to be both on the list of non-local labels and on
6147              the list of forced labels.  */
6148           FORCED_LABEL (label) = 0;
6149           return const0_rtx;
6150         }
6151       break;
6152
6153     case BUILT_IN_SETJMP_DISPATCHER:
6154        /* __builtin_setjmp_dispatcher is passed the dispatcher label.  */
6155       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6156         {
6157           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6158           rtx label_r = label_rtx (label);
6159
6160           /* Remove the dispatcher label from the list of non-local labels
6161              since the receiver labels have been added to it above.  */
6162           remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6163           return const0_rtx;
6164         }
6165       break;
6166
6167     case BUILT_IN_SETJMP_RECEIVER:
6168        /* __builtin_setjmp_receiver is passed the receiver label.  */
6169       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6170         {
6171           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6172           rtx label_r = label_rtx (label);
6173
6174           expand_builtin_setjmp_receiver (label_r);
6175           return const0_rtx;
6176         }
6177       break;
6178
6179       /* __builtin_longjmp is passed a pointer to an array of five words.
6180          It's similar to the C library longjmp function but works with
6181          __builtin_setjmp above.  */
6182     case BUILT_IN_LONGJMP:
6183       if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6184         {
6185           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6186                                       VOIDmode, EXPAND_NORMAL);
6187           rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6188
6189           if (value != const1_rtx)
6190             {
6191               error ("%<__builtin_longjmp%> second argument must be 1");
6192               return const0_rtx;
6193             }
6194
6195           expand_builtin_longjmp (buf_addr, value);
6196           return const0_rtx;
6197         }
6198       break;
6199
6200     case BUILT_IN_NONLOCAL_GOTO:
6201       target = expand_builtin_nonlocal_goto (exp);
6202       if (target)
6203         return target;
6204       break;
6205
6206       /* This updates the setjmp buffer that is its argument with the value
6207          of the current stack pointer.  */
6208     case BUILT_IN_UPDATE_SETJMP_BUF:
6209       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6210         {
6211           rtx buf_addr
6212             = expand_normal (CALL_EXPR_ARG (exp, 0));
6213
6214           expand_builtin_update_setjmp_buf (buf_addr);
6215           return const0_rtx;
6216         }
6217       break;
6218
6219     case BUILT_IN_TRAP:
6220       expand_builtin_trap ();
6221       return const0_rtx;
6222
6223     case BUILT_IN_UNREACHABLE:
6224       expand_builtin_unreachable ();
6225       return const0_rtx;
6226
6227     CASE_FLT_FN (BUILT_IN_SIGNBIT):
6228     case BUILT_IN_SIGNBITD32:
6229     case BUILT_IN_SIGNBITD64:
6230     case BUILT_IN_SIGNBITD128:
6231       target = expand_builtin_signbit (exp, target);
6232       if (target)
6233         return target;
6234       break;
6235
6236       /* Various hooks for the DWARF 2 __throw routine.  */
6237     case BUILT_IN_UNWIND_INIT:
6238       expand_builtin_unwind_init ();
6239       return const0_rtx;
6240     case BUILT_IN_DWARF_CFA:
6241       return virtual_cfa_rtx;
6242 #ifdef DWARF2_UNWIND_INFO
6243     case BUILT_IN_DWARF_SP_COLUMN:
6244       return expand_builtin_dwarf_sp_column ();
6245     case BUILT_IN_INIT_DWARF_REG_SIZES:
6246       expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6247       return const0_rtx;
6248 #endif
6249     case BUILT_IN_FROB_RETURN_ADDR:
6250       return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6251     case BUILT_IN_EXTRACT_RETURN_ADDR:
6252       return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6253     case BUILT_IN_EH_RETURN:
6254       expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6255                                 CALL_EXPR_ARG (exp, 1));
6256       return const0_rtx;
6257 #ifdef EH_RETURN_DATA_REGNO
6258     case BUILT_IN_EH_RETURN_DATA_REGNO:
6259       return expand_builtin_eh_return_data_regno (exp);
6260 #endif
6261     case BUILT_IN_EXTEND_POINTER:
6262       return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6263     case BUILT_IN_EH_POINTER:
6264       return expand_builtin_eh_pointer (exp);
6265     case BUILT_IN_EH_FILTER:
6266       return expand_builtin_eh_filter (exp);
6267     case BUILT_IN_EH_COPY_VALUES:
6268       return expand_builtin_eh_copy_values (exp);
6269
6270     case BUILT_IN_VA_START:
6271       return expand_builtin_va_start (exp);
6272     case BUILT_IN_VA_END:
6273       return expand_builtin_va_end (exp);
6274     case BUILT_IN_VA_COPY:
6275       return expand_builtin_va_copy (exp);
6276     case BUILT_IN_EXPECT:
6277       return expand_builtin_expect (exp, target);
6278     case BUILT_IN_PREFETCH:
6279       expand_builtin_prefetch (exp);
6280       return const0_rtx;
6281
6282     case BUILT_IN_PROFILE_FUNC_ENTER:
6283       return expand_builtin_profile_func (false);
6284     case BUILT_IN_PROFILE_FUNC_EXIT:
6285       return expand_builtin_profile_func (true);
6286
6287     case BUILT_IN_INIT_TRAMPOLINE:
6288       return expand_builtin_init_trampoline (exp);
6289     case BUILT_IN_ADJUST_TRAMPOLINE:
6290       return expand_builtin_adjust_trampoline (exp);
6291
6292     case BUILT_IN_FORK:
6293     case BUILT_IN_EXECL:
6294     case BUILT_IN_EXECV:
6295     case BUILT_IN_EXECLP:
6296     case BUILT_IN_EXECLE:
6297     case BUILT_IN_EXECVP:
6298     case BUILT_IN_EXECVE:
6299       target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6300       if (target)
6301         return target;
6302       break;
6303
6304     case BUILT_IN_FETCH_AND_ADD_1:
6305     case BUILT_IN_FETCH_AND_ADD_2:
6306     case BUILT_IN_FETCH_AND_ADD_4:
6307     case BUILT_IN_FETCH_AND_ADD_8:
6308     case BUILT_IN_FETCH_AND_ADD_16:
6309       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_ADD_1);
6310       target = expand_builtin_sync_operation (mode, exp, PLUS,
6311                                               false, target, ignore);
6312       if (target)
6313         return target;
6314       break;
6315
6316     case BUILT_IN_FETCH_AND_SUB_1:
6317     case BUILT_IN_FETCH_AND_SUB_2:
6318     case BUILT_IN_FETCH_AND_SUB_4:
6319     case BUILT_IN_FETCH_AND_SUB_8:
6320     case BUILT_IN_FETCH_AND_SUB_16:
6321       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_SUB_1);
6322       target = expand_builtin_sync_operation (mode, exp, MINUS,
6323                                               false, target, ignore);
6324       if (target)
6325         return target;
6326       break;
6327
6328     case BUILT_IN_FETCH_AND_OR_1:
6329     case BUILT_IN_FETCH_AND_OR_2:
6330     case BUILT_IN_FETCH_AND_OR_4:
6331     case BUILT_IN_FETCH_AND_OR_8:
6332     case BUILT_IN_FETCH_AND_OR_16:
6333       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_OR_1);
6334       target = expand_builtin_sync_operation (mode, exp, IOR,
6335                                               false, target, ignore);
6336       if (target)
6337         return target;
6338       break;
6339
6340     case BUILT_IN_FETCH_AND_AND_1:
6341     case BUILT_IN_FETCH_AND_AND_2:
6342     case BUILT_IN_FETCH_AND_AND_4:
6343     case BUILT_IN_FETCH_AND_AND_8:
6344     case BUILT_IN_FETCH_AND_AND_16:
6345       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_AND_1);
6346       target = expand_builtin_sync_operation (mode, exp, AND,
6347                                               false, target, ignore);
6348       if (target)
6349         return target;
6350       break;
6351
6352     case BUILT_IN_FETCH_AND_XOR_1:
6353     case BUILT_IN_FETCH_AND_XOR_2:
6354     case BUILT_IN_FETCH_AND_XOR_4:
6355     case BUILT_IN_FETCH_AND_XOR_8:
6356     case BUILT_IN_FETCH_AND_XOR_16:
6357       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_XOR_1);
6358       target = expand_builtin_sync_operation (mode, exp, XOR,
6359                                               false, target, ignore);
6360       if (target)
6361         return target;
6362       break;
6363
6364     case BUILT_IN_FETCH_AND_NAND_1:
6365     case BUILT_IN_FETCH_AND_NAND_2:
6366     case BUILT_IN_FETCH_AND_NAND_4:
6367     case BUILT_IN_FETCH_AND_NAND_8:
6368     case BUILT_IN_FETCH_AND_NAND_16:
6369       mode = get_builtin_sync_mode (fcode - BUILT_IN_FETCH_AND_NAND_1);
6370       target = expand_builtin_sync_operation (mode, exp, NOT,
6371                                               false, target, ignore);
6372       if (target)
6373         return target;
6374       break;
6375
6376     case BUILT_IN_ADD_AND_FETCH_1:
6377     case BUILT_IN_ADD_AND_FETCH_2:
6378     case BUILT_IN_ADD_AND_FETCH_4:
6379     case BUILT_IN_ADD_AND_FETCH_8:
6380     case BUILT_IN_ADD_AND_FETCH_16:
6381       mode = get_builtin_sync_mode (fcode - BUILT_IN_ADD_AND_FETCH_1);
6382       target = expand_builtin_sync_operation (mode, exp, PLUS,
6383                                               true, target, ignore);
6384       if (target)
6385         return target;
6386       break;
6387
6388     case BUILT_IN_SUB_AND_FETCH_1:
6389     case BUILT_IN_SUB_AND_FETCH_2:
6390     case BUILT_IN_SUB_AND_FETCH_4:
6391     case BUILT_IN_SUB_AND_FETCH_8:
6392     case BUILT_IN_SUB_AND_FETCH_16:
6393       mode = get_builtin_sync_mode (fcode - BUILT_IN_SUB_AND_FETCH_1);
6394       target = expand_builtin_sync_operation (mode, exp, MINUS,
6395                                               true, target, ignore);
6396       if (target)
6397         return target;
6398       break;
6399
6400     case BUILT_IN_OR_AND_FETCH_1:
6401     case BUILT_IN_OR_AND_FETCH_2:
6402     case BUILT_IN_OR_AND_FETCH_4:
6403     case BUILT_IN_OR_AND_FETCH_8:
6404     case BUILT_IN_OR_AND_FETCH_16:
6405       mode = get_builtin_sync_mode (fcode - BUILT_IN_OR_AND_FETCH_1);
6406       target = expand_builtin_sync_operation (mode, exp, IOR,
6407                                               true, target, ignore);
6408       if (target)
6409         return target;
6410       break;
6411
6412     case BUILT_IN_AND_AND_FETCH_1:
6413     case BUILT_IN_AND_AND_FETCH_2:
6414     case BUILT_IN_AND_AND_FETCH_4:
6415     case BUILT_IN_AND_AND_FETCH_8:
6416     case BUILT_IN_AND_AND_FETCH_16:
6417       mode = get_builtin_sync_mode (fcode - BUILT_IN_AND_AND_FETCH_1);
6418       target = expand_builtin_sync_operation (mode, exp, AND,
6419                                               true, target, ignore);
6420       if (target)
6421         return target;
6422       break;
6423
6424     case BUILT_IN_XOR_AND_FETCH_1:
6425     case BUILT_IN_XOR_AND_FETCH_2:
6426     case BUILT_IN_XOR_AND_FETCH_4:
6427     case BUILT_IN_XOR_AND_FETCH_8:
6428     case BUILT_IN_XOR_AND_FETCH_16:
6429       mode = get_builtin_sync_mode (fcode - BUILT_IN_XOR_AND_FETCH_1);
6430       target = expand_builtin_sync_operation (mode, exp, XOR,
6431                                               true, target, ignore);
6432       if (target)
6433         return target;
6434       break;
6435
6436     case BUILT_IN_NAND_AND_FETCH_1:
6437     case BUILT_IN_NAND_AND_FETCH_2:
6438     case BUILT_IN_NAND_AND_FETCH_4:
6439     case BUILT_IN_NAND_AND_FETCH_8:
6440     case BUILT_IN_NAND_AND_FETCH_16:
6441       mode = get_builtin_sync_mode (fcode - BUILT_IN_NAND_AND_FETCH_1);
6442       target = expand_builtin_sync_operation (mode, exp, NOT,
6443                                               true, target, ignore);
6444       if (target)
6445         return target;
6446       break;
6447
6448     case BUILT_IN_BOOL_COMPARE_AND_SWAP_1:
6449     case BUILT_IN_BOOL_COMPARE_AND_SWAP_2:
6450     case BUILT_IN_BOOL_COMPARE_AND_SWAP_4:
6451     case BUILT_IN_BOOL_COMPARE_AND_SWAP_8:
6452     case BUILT_IN_BOOL_COMPARE_AND_SWAP_16:
6453       if (mode == VOIDmode)
6454         mode = TYPE_MODE (boolean_type_node);
6455       if (!target || !register_operand (target, mode))
6456         target = gen_reg_rtx (mode);
6457
6458       mode = get_builtin_sync_mode (fcode - BUILT_IN_BOOL_COMPARE_AND_SWAP_1);
6459       target = expand_builtin_compare_and_swap (mode, exp, true, target);
6460       if (target)
6461         return target;
6462       break;
6463
6464     case BUILT_IN_VAL_COMPARE_AND_SWAP_1:
6465     case BUILT_IN_VAL_COMPARE_AND_SWAP_2:
6466     case BUILT_IN_VAL_COMPARE_AND_SWAP_4:
6467     case BUILT_IN_VAL_COMPARE_AND_SWAP_8:
6468     case BUILT_IN_VAL_COMPARE_AND_SWAP_16:
6469       mode = get_builtin_sync_mode (fcode - BUILT_IN_VAL_COMPARE_AND_SWAP_1);
6470       target = expand_builtin_compare_and_swap (mode, exp, false, target);
6471       if (target)
6472         return target;
6473       break;
6474
6475     case BUILT_IN_LOCK_TEST_AND_SET_1:
6476     case BUILT_IN_LOCK_TEST_AND_SET_2:
6477     case BUILT_IN_LOCK_TEST_AND_SET_4:
6478     case BUILT_IN_LOCK_TEST_AND_SET_8:
6479     case BUILT_IN_LOCK_TEST_AND_SET_16:
6480       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_TEST_AND_SET_1);
6481       target = expand_builtin_lock_test_and_set (mode, exp, target);
6482       if (target)
6483         return target;
6484       break;
6485
6486     case BUILT_IN_LOCK_RELEASE_1:
6487     case BUILT_IN_LOCK_RELEASE_2:
6488     case BUILT_IN_LOCK_RELEASE_4:
6489     case BUILT_IN_LOCK_RELEASE_8:
6490     case BUILT_IN_LOCK_RELEASE_16:
6491       mode = get_builtin_sync_mode (fcode - BUILT_IN_LOCK_RELEASE_1);
6492       expand_builtin_lock_release (mode, exp);
6493       return const0_rtx;
6494
6495     case BUILT_IN_SYNCHRONIZE:
6496       expand_builtin_synchronize ();
6497       return const0_rtx;
6498
6499     case BUILT_IN_OBJECT_SIZE:
6500       return expand_builtin_object_size (exp);
6501
6502     case BUILT_IN_MEMCPY_CHK:
6503     case BUILT_IN_MEMPCPY_CHK:
6504     case BUILT_IN_MEMMOVE_CHK:
6505     case BUILT_IN_MEMSET_CHK:
6506       target = expand_builtin_memory_chk (exp, target, mode, fcode);
6507       if (target)
6508         return target;
6509       break;
6510
6511     case BUILT_IN_STRCPY_CHK:
6512     case BUILT_IN_STPCPY_CHK:
6513     case BUILT_IN_STRNCPY_CHK:
6514     case BUILT_IN_STRCAT_CHK:
6515     case BUILT_IN_STRNCAT_CHK:
6516     case BUILT_IN_SNPRINTF_CHK:
6517     case BUILT_IN_VSNPRINTF_CHK:
6518       maybe_emit_chk_warning (exp, fcode);
6519       break;
6520
6521     case BUILT_IN_SPRINTF_CHK:
6522     case BUILT_IN_VSPRINTF_CHK:
6523       maybe_emit_sprintf_chk_warning (exp, fcode);
6524       break;
6525
6526     case BUILT_IN_FREE:
6527       maybe_emit_free_warning (exp);
6528       break;
6529
6530     default:    /* just do library call, if unknown builtin */
6531       break;
6532     }
6533
6534   /* The switch statement above can drop through to cause the function
6535      to be called normally.  */
6536   return expand_call (exp, target, ignore);
6537 }
6538
6539 /* Determine whether a tree node represents a call to a built-in
6540    function.  If the tree T is a call to a built-in function with
6541    the right number of arguments of the appropriate types, return
6542    the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6543    Otherwise the return value is END_BUILTINS.  */
6544
6545 enum built_in_function
6546 builtin_mathfn_code (const_tree t)
6547 {
6548   const_tree fndecl, arg, parmlist;
6549   const_tree argtype, parmtype;
6550   const_call_expr_arg_iterator iter;
6551
6552   if (TREE_CODE (t) != CALL_EXPR
6553       || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6554     return END_BUILTINS;
6555
6556   fndecl = get_callee_fndecl (t);
6557   if (fndecl == NULL_TREE
6558       || TREE_CODE (fndecl) != FUNCTION_DECL
6559       || ! DECL_BUILT_IN (fndecl)
6560       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6561     return END_BUILTINS;
6562
6563   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6564   init_const_call_expr_arg_iterator (t, &iter);
6565   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6566     {
6567       /* If a function doesn't take a variable number of arguments,
6568          the last element in the list will have type `void'.  */
6569       parmtype = TREE_VALUE (parmlist);
6570       if (VOID_TYPE_P (parmtype))
6571         {
6572           if (more_const_call_expr_args_p (&iter))
6573             return END_BUILTINS;
6574           return DECL_FUNCTION_CODE (fndecl);
6575         }
6576
6577       if (! more_const_call_expr_args_p (&iter))
6578         return END_BUILTINS;
6579
6580       arg = next_const_call_expr_arg (&iter);
6581       argtype = TREE_TYPE (arg);
6582
6583       if (SCALAR_FLOAT_TYPE_P (parmtype))
6584         {
6585           if (! SCALAR_FLOAT_TYPE_P (argtype))
6586             return END_BUILTINS;
6587         }
6588       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6589         {
6590           if (! COMPLEX_FLOAT_TYPE_P (argtype))
6591             return END_BUILTINS;
6592         }
6593       else if (POINTER_TYPE_P (parmtype))
6594         {
6595           if (! POINTER_TYPE_P (argtype))
6596             return END_BUILTINS;
6597         }
6598       else if (INTEGRAL_TYPE_P (parmtype))
6599         {
6600           if (! INTEGRAL_TYPE_P (argtype))
6601             return END_BUILTINS;
6602         }
6603       else
6604         return END_BUILTINS;
6605     }
6606
6607   /* Variable-length argument list.  */
6608   return DECL_FUNCTION_CODE (fndecl);
6609 }
6610
6611 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6612    evaluate to a constant.  */
6613
6614 static tree
6615 fold_builtin_constant_p (tree arg)
6616 {
6617   /* We return 1 for a numeric type that's known to be a constant
6618      value at compile-time or for an aggregate type that's a
6619      literal constant.  */
6620   STRIP_NOPS (arg);
6621
6622   /* If we know this is a constant, emit the constant of one.  */
6623   if (CONSTANT_CLASS_P (arg)
6624       || (TREE_CODE (arg) == CONSTRUCTOR
6625           && TREE_CONSTANT (arg)))
6626     return integer_one_node;
6627   if (TREE_CODE (arg) == ADDR_EXPR)
6628     {
6629        tree op = TREE_OPERAND (arg, 0);
6630        if (TREE_CODE (op) == STRING_CST
6631            || (TREE_CODE (op) == ARRAY_REF
6632                && integer_zerop (TREE_OPERAND (op, 1))
6633                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6634          return integer_one_node;
6635     }
6636
6637   /* If this expression has side effects, show we don't know it to be a
6638      constant.  Likewise if it's a pointer or aggregate type since in
6639      those case we only want literals, since those are only optimized
6640      when generating RTL, not later.
6641      And finally, if we are compiling an initializer, not code, we
6642      need to return a definite result now; there's not going to be any
6643      more optimization done.  */
6644   if (TREE_SIDE_EFFECTS (arg)
6645       || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6646       || POINTER_TYPE_P (TREE_TYPE (arg))
6647       || cfun == 0
6648       || folding_initializer)
6649     return integer_zero_node;
6650
6651   return NULL_TREE;
6652 }
6653
6654 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6655    return it as a truthvalue.  */
6656
6657 static tree
6658 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6659 {
6660   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6661
6662   fn = built_in_decls[BUILT_IN_EXPECT];
6663   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6664   ret_type = TREE_TYPE (TREE_TYPE (fn));
6665   pred_type = TREE_VALUE (arg_types);
6666   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6667
6668   pred = fold_convert_loc (loc, pred_type, pred);
6669   expected = fold_convert_loc (loc, expected_type, expected);
6670   call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6671
6672   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6673                  build_int_cst (ret_type, 0));
6674 }
6675
6676 /* Fold a call to builtin_expect with arguments ARG0 and ARG1.  Return
6677    NULL_TREE if no simplification is possible.  */
6678
6679 static tree
6680 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
6681 {
6682   tree inner, fndecl;
6683   enum tree_code code;
6684
6685   /* If this is a builtin_expect within a builtin_expect keep the
6686      inner one.  See through a comparison against a constant.  It
6687      might have been added to create a thruthvalue.  */
6688   inner = arg0;
6689   if (COMPARISON_CLASS_P (inner)
6690       && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6691     inner = TREE_OPERAND (inner, 0);
6692
6693   if (TREE_CODE (inner) == CALL_EXPR
6694       && (fndecl = get_callee_fndecl (inner))
6695       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6696       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6697     return arg0;
6698
6699   /* Distribute the expected value over short-circuiting operators.
6700      See through the cast from truthvalue_type_node to long.  */
6701   inner = arg0;
6702   while (TREE_CODE (inner) == NOP_EXPR
6703          && INTEGRAL_TYPE_P (TREE_TYPE (inner))
6704          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner, 0))))
6705     inner = TREE_OPERAND (inner, 0);
6706
6707   code = TREE_CODE (inner);
6708   if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6709     {
6710       tree op0 = TREE_OPERAND (inner, 0);
6711       tree op1 = TREE_OPERAND (inner, 1);
6712
6713       op0 = build_builtin_expect_predicate (loc, op0, arg1);
6714       op1 = build_builtin_expect_predicate (loc, op1, arg1);
6715       inner = build2 (code, TREE_TYPE (inner), op0, op1);
6716
6717       return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6718     }
6719
6720   /* If the argument isn't invariant then there's nothing else we can do.  */
6721   if (!TREE_CONSTANT (arg0))
6722     return NULL_TREE;
6723
6724   /* If we expect that a comparison against the argument will fold to
6725      a constant return the constant.  In practice, this means a true
6726      constant or the address of a non-weak symbol.  */
6727   inner = arg0;
6728   STRIP_NOPS (inner);
6729   if (TREE_CODE (inner) == ADDR_EXPR)
6730     {
6731       do
6732         {
6733           inner = TREE_OPERAND (inner, 0);
6734         }
6735       while (TREE_CODE (inner) == COMPONENT_REF
6736              || TREE_CODE (inner) == ARRAY_REF);
6737       if ((TREE_CODE (inner) == VAR_DECL
6738            || TREE_CODE (inner) == FUNCTION_DECL)
6739           && DECL_WEAK (inner))
6740         return NULL_TREE;
6741     }
6742
6743   /* Otherwise, ARG0 already has the proper type for the return value.  */
6744   return arg0;
6745 }
6746
6747 /* Fold a call to __builtin_classify_type with argument ARG.  */
6748
6749 static tree
6750 fold_builtin_classify_type (tree arg)
6751 {
6752   if (arg == 0)
6753     return build_int_cst (NULL_TREE, no_type_class);
6754
6755   return build_int_cst (NULL_TREE, type_to_class (TREE_TYPE (arg)));
6756 }
6757
6758 /* Fold a call to __builtin_strlen with argument ARG.  */
6759
6760 static tree
6761 fold_builtin_strlen (location_t loc, tree type, tree arg)
6762 {
6763   if (!validate_arg (arg, POINTER_TYPE))
6764     return NULL_TREE;
6765   else
6766     {
6767       tree len = c_strlen (arg, 0);
6768
6769       if (len)
6770         return fold_convert_loc (loc, type, len);
6771
6772       return NULL_TREE;
6773     }
6774 }
6775
6776 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
6777
6778 static tree
6779 fold_builtin_inf (location_t loc, tree type, int warn)
6780 {
6781   REAL_VALUE_TYPE real;
6782
6783   /* __builtin_inff is intended to be usable to define INFINITY on all
6784      targets.  If an infinity is not available, INFINITY expands "to a
6785      positive constant of type float that overflows at translation
6786      time", footnote "In this case, using INFINITY will violate the
6787      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
6788      Thus we pedwarn to ensure this constraint violation is
6789      diagnosed.  */
6790   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
6791     pedwarn (loc, 0, "target format does not support infinity");
6792
6793   real_inf (&real);
6794   return build_real (type, real);
6795 }
6796
6797 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG.  */
6798
6799 static tree
6800 fold_builtin_nan (tree arg, tree type, int quiet)
6801 {
6802   REAL_VALUE_TYPE real;
6803   const char *str;
6804
6805   if (!validate_arg (arg, POINTER_TYPE))
6806     return NULL_TREE;
6807   str = c_getstr (arg);
6808   if (!str)
6809     return NULL_TREE;
6810
6811   if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
6812     return NULL_TREE;
6813
6814   return build_real (type, real);
6815 }
6816
6817 /* Return true if the floating point expression T has an integer value.
6818    We also allow +Inf, -Inf and NaN to be considered integer values.  */
6819
6820 static bool
6821 integer_valued_real_p (tree t)
6822 {
6823   switch (TREE_CODE (t))
6824     {
6825     case FLOAT_EXPR:
6826       return true;
6827
6828     case ABS_EXPR:
6829     case SAVE_EXPR:
6830       return integer_valued_real_p (TREE_OPERAND (t, 0));
6831
6832     case COMPOUND_EXPR:
6833     case MODIFY_EXPR:
6834     case BIND_EXPR:
6835       return integer_valued_real_p (TREE_OPERAND (t, 1));
6836
6837     case PLUS_EXPR:
6838     case MINUS_EXPR:
6839     case MULT_EXPR:
6840     case MIN_EXPR:
6841     case MAX_EXPR:
6842       return integer_valued_real_p (TREE_OPERAND (t, 0))
6843              && integer_valued_real_p (TREE_OPERAND (t, 1));
6844
6845     case COND_EXPR:
6846       return integer_valued_real_p (TREE_OPERAND (t, 1))
6847              && integer_valued_real_p (TREE_OPERAND (t, 2));
6848
6849     case REAL_CST:
6850       return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
6851
6852     case NOP_EXPR:
6853       {
6854         tree type = TREE_TYPE (TREE_OPERAND (t, 0));
6855         if (TREE_CODE (type) == INTEGER_TYPE)
6856           return true;
6857         if (TREE_CODE (type) == REAL_TYPE)
6858           return integer_valued_real_p (TREE_OPERAND (t, 0));
6859         break;
6860       }
6861
6862     case CALL_EXPR:
6863       switch (builtin_mathfn_code (t))
6864         {
6865         CASE_FLT_FN (BUILT_IN_CEIL):
6866         CASE_FLT_FN (BUILT_IN_FLOOR):
6867         CASE_FLT_FN (BUILT_IN_NEARBYINT):
6868         CASE_FLT_FN (BUILT_IN_RINT):
6869         CASE_FLT_FN (BUILT_IN_ROUND):
6870         CASE_FLT_FN (BUILT_IN_TRUNC):
6871           return true;
6872
6873         CASE_FLT_FN (BUILT_IN_FMIN):
6874         CASE_FLT_FN (BUILT_IN_FMAX):
6875           return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
6876             && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
6877
6878         default:
6879           break;
6880         }
6881       break;
6882
6883     default:
6884       break;
6885     }
6886   return false;
6887 }
6888
6889 /* FNDECL is assumed to be a builtin where truncation can be propagated
6890    across (for instance floor((double)f) == (double)floorf (f).
6891    Do the transformation for a call with argument ARG.  */
6892
6893 static tree
6894 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
6895 {
6896   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6897
6898   if (!validate_arg (arg, REAL_TYPE))
6899     return NULL_TREE;
6900
6901   /* Integer rounding functions are idempotent.  */
6902   if (fcode == builtin_mathfn_code (arg))
6903     return arg;
6904
6905   /* If argument is already integer valued, and we don't need to worry
6906      about setting errno, there's no need to perform rounding.  */
6907   if (! flag_errno_math && integer_valued_real_p (arg))
6908     return arg;
6909
6910   if (optimize)
6911     {
6912       tree arg0 = strip_float_extensions (arg);
6913       tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
6914       tree newtype = TREE_TYPE (arg0);
6915       tree decl;
6916
6917       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6918           && (decl = mathfn_built_in (newtype, fcode)))
6919         return fold_convert_loc (loc, ftype,
6920                                  build_call_expr_loc (loc, decl, 1,
6921                                                   fold_convert_loc (loc,
6922                                                                     newtype,
6923                                                                     arg0)));
6924     }
6925   return NULL_TREE;
6926 }
6927
6928 /* FNDECL is assumed to be builtin which can narrow the FP type of
6929    the argument, for instance lround((double)f) -> lroundf (f).
6930    Do the transformation for a call with argument ARG.  */
6931
6932 static tree
6933 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
6934 {
6935   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6936
6937   if (!validate_arg (arg, REAL_TYPE))
6938     return NULL_TREE;
6939
6940   /* If argument is already integer valued, and we don't need to worry
6941      about setting errno, there's no need to perform rounding.  */
6942   if (! flag_errno_math && integer_valued_real_p (arg))
6943     return fold_build1_loc (loc, FIX_TRUNC_EXPR,
6944                         TREE_TYPE (TREE_TYPE (fndecl)), arg);
6945
6946   if (optimize)
6947     {
6948       tree ftype = TREE_TYPE (arg);
6949       tree arg0 = strip_float_extensions (arg);
6950       tree newtype = TREE_TYPE (arg0);
6951       tree decl;
6952
6953       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
6954           && (decl = mathfn_built_in (newtype, fcode)))
6955         return build_call_expr_loc (loc, decl, 1,
6956                                 fold_convert_loc (loc, newtype, arg0));
6957     }
6958
6959   /* Canonicalize llround (x) to lround (x) on LP64 targets where
6960      sizeof (long long) == sizeof (long).  */
6961   if (TYPE_PRECISION (long_long_integer_type_node)
6962       == TYPE_PRECISION (long_integer_type_node))
6963     {
6964       tree newfn = NULL_TREE;
6965       switch (fcode)
6966         {
6967         CASE_FLT_FN (BUILT_IN_LLCEIL):
6968           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
6969           break;
6970
6971         CASE_FLT_FN (BUILT_IN_LLFLOOR):
6972           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
6973           break;
6974
6975         CASE_FLT_FN (BUILT_IN_LLROUND):
6976           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
6977           break;
6978
6979         CASE_FLT_FN (BUILT_IN_LLRINT):
6980           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
6981           break;
6982
6983         default:
6984           break;
6985         }
6986
6987       if (newfn)
6988         {
6989           tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
6990           return fold_convert_loc (loc,
6991                                    TREE_TYPE (TREE_TYPE (fndecl)), newcall);
6992         }
6993     }
6994
6995   return NULL_TREE;
6996 }
6997
6998 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG.  TYPE is the
6999    return type.  Return NULL_TREE if no simplification can be made.  */
7000
7001 static tree
7002 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7003 {
7004   tree res;
7005
7006   if (!validate_arg (arg, COMPLEX_TYPE)
7007       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7008     return NULL_TREE;
7009
7010   /* Calculate the result when the argument is a constant.  */
7011   if (TREE_CODE (arg) == COMPLEX_CST
7012       && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7013                               type, mpfr_hypot)))
7014     return res;
7015
7016   if (TREE_CODE (arg) == COMPLEX_EXPR)
7017     {
7018       tree real = TREE_OPERAND (arg, 0);
7019       tree imag = TREE_OPERAND (arg, 1);
7020
7021       /* If either part is zero, cabs is fabs of the other.  */
7022       if (real_zerop (real))
7023         return fold_build1_loc (loc, ABS_EXPR, type, imag);
7024       if (real_zerop (imag))
7025         return fold_build1_loc (loc, ABS_EXPR, type, real);
7026
7027       /* cabs(x+xi) -> fabs(x)*sqrt(2).  */
7028       if (flag_unsafe_math_optimizations
7029           && operand_equal_p (real, imag, OEP_PURE_SAME))
7030         {
7031           const REAL_VALUE_TYPE sqrt2_trunc
7032             = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7033           STRIP_NOPS (real);
7034           return fold_build2_loc (loc, MULT_EXPR, type,
7035                               fold_build1_loc (loc, ABS_EXPR, type, real),
7036                               build_real (type, sqrt2_trunc));
7037         }
7038     }
7039
7040   /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z).  */
7041   if (TREE_CODE (arg) == NEGATE_EXPR
7042       || TREE_CODE (arg) == CONJ_EXPR)
7043     return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7044
7045   /* Don't do this when optimizing for size.  */
7046   if (flag_unsafe_math_optimizations
7047       && optimize && optimize_function_for_speed_p (cfun))
7048     {
7049       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7050
7051       if (sqrtfn != NULL_TREE)
7052         {
7053           tree rpart, ipart, result;
7054
7055           arg = builtin_save_expr (arg);
7056
7057           rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7058           ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7059
7060           rpart = builtin_save_expr (rpart);
7061           ipart = builtin_save_expr (ipart);
7062
7063           result = fold_build2_loc (loc, PLUS_EXPR, type,
7064                                 fold_build2_loc (loc, MULT_EXPR, type,
7065                                              rpart, rpart),
7066                                 fold_build2_loc (loc, MULT_EXPR, type,
7067                                              ipart, ipart));
7068
7069           return build_call_expr_loc (loc, sqrtfn, 1, result);
7070         }
7071     }
7072
7073   return NULL_TREE;
7074 }
7075
7076 /* Build a complex (inf +- 0i) for the result of cproj.  TYPE is the
7077    complex tree type of the result.  If NEG is true, the imaginary
7078    zero is negative.  */
7079
7080 static tree
7081 build_complex_cproj (tree type, bool neg)
7082 {
7083   REAL_VALUE_TYPE rinf, rzero = dconst0;
7084
7085   real_inf (&rinf);
7086   rzero.sign = neg;
7087   return build_complex (type, build_real (TREE_TYPE (type), rinf),
7088                         build_real (TREE_TYPE (type), rzero));
7089 }
7090
7091 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG.  TYPE is the
7092    return type.  Return NULL_TREE if no simplification can be made.  */
7093
7094 static tree
7095 fold_builtin_cproj (location_t loc, tree arg, tree type)
7096 {
7097   if (!validate_arg (arg, COMPLEX_TYPE)
7098       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7099     return NULL_TREE;
7100
7101   /* If there are no infinities, return arg.  */
7102   if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type))))
7103     return non_lvalue_loc (loc, arg);
7104
7105   /* Calculate the result when the argument is a constant.  */
7106   if (TREE_CODE (arg) == COMPLEX_CST)
7107     {
7108       const REAL_VALUE_TYPE *real = TREE_REAL_CST_PTR (TREE_REALPART (arg));
7109       const REAL_VALUE_TYPE *imag = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
7110
7111       if (real_isinf (real) || real_isinf (imag))
7112         return build_complex_cproj (type, imag->sign);
7113       else
7114         return arg;
7115     }
7116   else if (TREE_CODE (arg) == COMPLEX_EXPR)
7117     {
7118       tree real = TREE_OPERAND (arg, 0);
7119       tree imag = TREE_OPERAND (arg, 1);
7120
7121       STRIP_NOPS (real);
7122       STRIP_NOPS (imag);
7123
7124       /* If the real part is inf and the imag part is known to be
7125          nonnegative, return (inf + 0i).  Remember side-effects are
7126          possible in the imag part.  */
7127       if (TREE_CODE (real) == REAL_CST
7128           && real_isinf (TREE_REAL_CST_PTR (real))
7129           && tree_expr_nonnegative_p (imag))
7130         return omit_one_operand_loc (loc, type,
7131                                      build_complex_cproj (type, false),
7132                                      arg);
7133
7134       /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7135          Remember side-effects are possible in the real part.  */
7136       if (TREE_CODE (imag) == REAL_CST
7137           && real_isinf (TREE_REAL_CST_PTR (imag)))
7138         return
7139           omit_one_operand_loc (loc, type,
7140                                 build_complex_cproj (type, TREE_REAL_CST_PTR
7141                                                      (imag)->sign), arg);
7142     }
7143
7144   return NULL_TREE;
7145 }
7146
7147 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7148    Return NULL_TREE if no simplification can be made.  */
7149
7150 static tree
7151 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7152 {
7153
7154   enum built_in_function fcode;
7155   tree res;
7156
7157   if (!validate_arg (arg, REAL_TYPE))
7158     return NULL_TREE;
7159
7160   /* Calculate the result when the argument is a constant.  */
7161   if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7162     return res;
7163
7164   /* Optimize sqrt(expN(x)) = expN(x*0.5).  */
7165   fcode = builtin_mathfn_code (arg);
7166   if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7167     {
7168       tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7169       arg = fold_build2_loc (loc, MULT_EXPR, type,
7170                          CALL_EXPR_ARG (arg, 0),
7171                          build_real (type, dconsthalf));
7172       return build_call_expr_loc (loc, expfn, 1, arg);
7173     }
7174
7175   /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)).  */
7176   if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7177     {
7178       tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7179
7180       if (powfn)
7181         {
7182           tree arg0 = CALL_EXPR_ARG (arg, 0);
7183           tree tree_root;
7184           /* The inner root was either sqrt or cbrt.  */
7185           /* This was a conditional expression but it triggered a bug
7186              in Sun C 5.5.  */
7187           REAL_VALUE_TYPE dconstroot;
7188           if (BUILTIN_SQRT_P (fcode))
7189             dconstroot = dconsthalf;
7190           else
7191             dconstroot = dconst_third ();
7192
7193           /* Adjust for the outer root.  */
7194           SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7195           dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7196           tree_root = build_real (type, dconstroot);
7197           return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7198         }
7199     }
7200
7201   /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5).  */
7202   if (flag_unsafe_math_optimizations
7203       && (fcode == BUILT_IN_POW
7204           || fcode == BUILT_IN_POWF
7205           || fcode == BUILT_IN_POWL))
7206     {
7207       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7208       tree arg0 = CALL_EXPR_ARG (arg, 0);
7209       tree arg1 = CALL_EXPR_ARG (arg, 1);
7210       tree narg1;
7211       if (!tree_expr_nonnegative_p (arg0))
7212         arg0 = build1 (ABS_EXPR, type, arg0);
7213       narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7214                            build_real (type, dconsthalf));
7215       return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7216     }
7217
7218   return NULL_TREE;
7219 }
7220
7221 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7222    Return NULL_TREE if no simplification can be made.  */
7223
7224 static tree
7225 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7226 {
7227   const enum built_in_function fcode = builtin_mathfn_code (arg);
7228   tree res;
7229
7230   if (!validate_arg (arg, REAL_TYPE))
7231     return NULL_TREE;
7232
7233   /* Calculate the result when the argument is a constant.  */
7234   if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7235     return res;
7236
7237   if (flag_unsafe_math_optimizations)
7238     {
7239       /* Optimize cbrt(expN(x)) -> expN(x/3).  */
7240       if (BUILTIN_EXPONENT_P (fcode))
7241         {
7242           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7243           const REAL_VALUE_TYPE third_trunc =
7244             real_value_truncate (TYPE_MODE (type), dconst_third ());
7245           arg = fold_build2_loc (loc, MULT_EXPR, type,
7246                              CALL_EXPR_ARG (arg, 0),
7247                              build_real (type, third_trunc));
7248           return build_call_expr_loc (loc, expfn, 1, arg);
7249         }
7250
7251       /* Optimize cbrt(sqrt(x)) -> pow(x,1/6).  */
7252       if (BUILTIN_SQRT_P (fcode))
7253         {
7254           tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7255
7256           if (powfn)
7257             {
7258               tree arg0 = CALL_EXPR_ARG (arg, 0);
7259               tree tree_root;
7260               REAL_VALUE_TYPE dconstroot = dconst_third ();
7261
7262               SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7263               dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7264               tree_root = build_real (type, dconstroot);
7265               return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7266             }
7267         }
7268
7269       /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative.  */
7270       if (BUILTIN_CBRT_P (fcode))
7271         {
7272           tree arg0 = CALL_EXPR_ARG (arg, 0);
7273           if (tree_expr_nonnegative_p (arg0))
7274             {
7275               tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7276
7277               if (powfn)
7278                 {
7279                   tree tree_root;
7280                   REAL_VALUE_TYPE dconstroot;
7281
7282                   real_arithmetic (&dconstroot, MULT_EXPR,
7283                                    dconst_third_ptr (), dconst_third_ptr ());
7284                   dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7285                   tree_root = build_real (type, dconstroot);
7286                   return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7287                 }
7288             }
7289         }
7290
7291       /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative.  */
7292       if (fcode == BUILT_IN_POW
7293           || fcode == BUILT_IN_POWF
7294           || fcode == BUILT_IN_POWL)
7295         {
7296           tree arg00 = CALL_EXPR_ARG (arg, 0);
7297           tree arg01 = CALL_EXPR_ARG (arg, 1);
7298           if (tree_expr_nonnegative_p (arg00))
7299             {
7300               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7301               const REAL_VALUE_TYPE dconstroot
7302                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7303               tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7304                                          build_real (type, dconstroot));
7305               return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7306             }
7307         }
7308     }
7309   return NULL_TREE;
7310 }
7311
7312 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7313    TYPE is the type of the return value.  Return NULL_TREE if no
7314    simplification can be made.  */
7315
7316 static tree
7317 fold_builtin_cos (location_t loc,
7318                   tree arg, tree type, tree fndecl)
7319 {
7320   tree res, narg;
7321
7322   if (!validate_arg (arg, REAL_TYPE))
7323     return NULL_TREE;
7324
7325   /* Calculate the result when the argument is a constant.  */
7326   if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7327     return res;
7328
7329   /* Optimize cos(-x) into cos (x).  */
7330   if ((narg = fold_strip_sign_ops (arg)))
7331     return build_call_expr_loc (loc, fndecl, 1, narg);
7332
7333   return NULL_TREE;
7334 }
7335
7336 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7337    Return NULL_TREE if no simplification can be made.  */
7338
7339 static tree
7340 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7341 {
7342   if (validate_arg (arg, REAL_TYPE))
7343     {
7344       tree res, narg;
7345
7346       /* Calculate the result when the argument is a constant.  */
7347       if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7348         return res;
7349
7350       /* Optimize cosh(-x) into cosh (x).  */
7351       if ((narg = fold_strip_sign_ops (arg)))
7352         return build_call_expr_loc (loc, fndecl, 1, narg);
7353     }
7354
7355   return NULL_TREE;
7356 }
7357
7358 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7359    argument ARG.  TYPE is the type of the return value.  Return
7360    NULL_TREE if no simplification can be made.  */
7361
7362 static tree
7363 fold_builtin_ccos (location_t loc, tree arg, tree type, tree fndecl,
7364                    bool hyper)
7365 {
7366   if (validate_arg (arg, COMPLEX_TYPE)
7367       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7368     {
7369       tree tmp;
7370
7371       /* Calculate the result when the argument is a constant.  */
7372       if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7373         return tmp;
7374
7375       /* Optimize fn(-x) into fn(x).  */
7376       if ((tmp = fold_strip_sign_ops (arg)))
7377         return build_call_expr_loc (loc, fndecl, 1, tmp);
7378     }
7379
7380   return NULL_TREE;
7381 }
7382
7383 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7384    Return NULL_TREE if no simplification can be made.  */
7385
7386 static tree
7387 fold_builtin_tan (tree arg, tree type)
7388 {
7389   enum built_in_function fcode;
7390   tree res;
7391
7392   if (!validate_arg (arg, REAL_TYPE))
7393     return NULL_TREE;
7394
7395   /* Calculate the result when the argument is a constant.  */
7396   if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7397     return res;
7398
7399   /* Optimize tan(atan(x)) = x.  */
7400   fcode = builtin_mathfn_code (arg);
7401   if (flag_unsafe_math_optimizations
7402       && (fcode == BUILT_IN_ATAN
7403           || fcode == BUILT_IN_ATANF
7404           || fcode == BUILT_IN_ATANL))
7405     return CALL_EXPR_ARG (arg, 0);
7406
7407   return NULL_TREE;
7408 }
7409
7410 /* Fold function call to builtin sincos, sincosf, or sincosl.  Return
7411    NULL_TREE if no simplification can be made.  */
7412
7413 static tree
7414 fold_builtin_sincos (location_t loc,
7415                      tree arg0, tree arg1, tree arg2)
7416 {
7417   tree type;
7418   tree res, fn, call;
7419
7420   if (!validate_arg (arg0, REAL_TYPE)
7421       || !validate_arg (arg1, POINTER_TYPE)
7422       || !validate_arg (arg2, POINTER_TYPE))
7423     return NULL_TREE;
7424
7425   type = TREE_TYPE (arg0);
7426
7427   /* Calculate the result when the argument is a constant.  */
7428   if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7429     return res;
7430
7431   /* Canonicalize sincos to cexpi.  */
7432   if (!TARGET_C99_FUNCTIONS)
7433     return NULL_TREE;
7434   fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7435   if (!fn)
7436     return NULL_TREE;
7437
7438   call = build_call_expr_loc (loc, fn, 1, arg0);
7439   call = builtin_save_expr (call);
7440
7441   return build2 (COMPOUND_EXPR, void_type_node,
7442                  build2 (MODIFY_EXPR, void_type_node,
7443                          build_fold_indirect_ref_loc (loc, arg1),
7444                          build1 (IMAGPART_EXPR, type, call)),
7445                  build2 (MODIFY_EXPR, void_type_node,
7446                          build_fold_indirect_ref_loc (loc, arg2),
7447                          build1 (REALPART_EXPR, type, call)));
7448 }
7449
7450 /* Fold function call to builtin cexp, cexpf, or cexpl.  Return
7451    NULL_TREE if no simplification can be made.  */
7452
7453 static tree
7454 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7455 {
7456   tree rtype;
7457   tree realp, imagp, ifn;
7458   tree res;
7459
7460   if (!validate_arg (arg0, COMPLEX_TYPE)
7461       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7462     return NULL_TREE;
7463
7464   /* Calculate the result when the argument is a constant.  */
7465   if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7466     return res;
7467
7468   rtype = TREE_TYPE (TREE_TYPE (arg0));
7469
7470   /* In case we can figure out the real part of arg0 and it is constant zero
7471      fold to cexpi.  */
7472   if (!TARGET_C99_FUNCTIONS)
7473     return NULL_TREE;
7474   ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7475   if (!ifn)
7476     return NULL_TREE;
7477
7478   if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7479       && real_zerop (realp))
7480     {
7481       tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7482       return build_call_expr_loc (loc, ifn, 1, narg);
7483     }
7484
7485   /* In case we can easily decompose real and imaginary parts split cexp
7486      to exp (r) * cexpi (i).  */
7487   if (flag_unsafe_math_optimizations
7488       && realp)
7489     {
7490       tree rfn, rcall, icall;
7491
7492       rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7493       if (!rfn)
7494         return NULL_TREE;
7495
7496       imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7497       if (!imagp)
7498         return NULL_TREE;
7499
7500       icall = build_call_expr_loc (loc, ifn, 1, imagp);
7501       icall = builtin_save_expr (icall);
7502       rcall = build_call_expr_loc (loc, rfn, 1, realp);
7503       rcall = builtin_save_expr (rcall);
7504       return fold_build2_loc (loc, COMPLEX_EXPR, type,
7505                           fold_build2_loc (loc, MULT_EXPR, rtype,
7506                                        rcall,
7507                                        fold_build1_loc (loc, REALPART_EXPR,
7508                                                     rtype, icall)),
7509                           fold_build2_loc (loc, MULT_EXPR, rtype,
7510                                        rcall,
7511                                        fold_build1_loc (loc, IMAGPART_EXPR,
7512                                                     rtype, icall)));
7513     }
7514
7515   return NULL_TREE;
7516 }
7517
7518 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7519    Return NULL_TREE if no simplification can be made.  */
7520
7521 static tree
7522 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7523 {
7524   if (!validate_arg (arg, REAL_TYPE))
7525     return NULL_TREE;
7526
7527   /* Optimize trunc of constant value.  */
7528   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7529     {
7530       REAL_VALUE_TYPE r, x;
7531       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7532
7533       x = TREE_REAL_CST (arg);
7534       real_trunc (&r, TYPE_MODE (type), &x);
7535       return build_real (type, r);
7536     }
7537
7538   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7539 }
7540
7541 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7542    Return NULL_TREE if no simplification can be made.  */
7543
7544 static tree
7545 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7546 {
7547   if (!validate_arg (arg, REAL_TYPE))
7548     return NULL_TREE;
7549
7550   /* Optimize floor of constant value.  */
7551   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7552     {
7553       REAL_VALUE_TYPE x;
7554
7555       x = TREE_REAL_CST (arg);
7556       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7557         {
7558           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7559           REAL_VALUE_TYPE r;
7560
7561           real_floor (&r, TYPE_MODE (type), &x);
7562           return build_real (type, r);
7563         }
7564     }
7565
7566   /* Fold floor (x) where x is nonnegative to trunc (x).  */
7567   if (tree_expr_nonnegative_p (arg))
7568     {
7569       tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7570       if (truncfn)
7571         return build_call_expr_loc (loc, truncfn, 1, arg);
7572     }
7573
7574   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7575 }
7576
7577 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7578    Return NULL_TREE if no simplification can be made.  */
7579
7580 static tree
7581 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7582 {
7583   if (!validate_arg (arg, REAL_TYPE))
7584     return NULL_TREE;
7585
7586   /* Optimize ceil of constant value.  */
7587   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7588     {
7589       REAL_VALUE_TYPE x;
7590
7591       x = TREE_REAL_CST (arg);
7592       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7593         {
7594           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7595           REAL_VALUE_TYPE r;
7596
7597           real_ceil (&r, TYPE_MODE (type), &x);
7598           return build_real (type, r);
7599         }
7600     }
7601
7602   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7603 }
7604
7605 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7606    Return NULL_TREE if no simplification can be made.  */
7607
7608 static tree
7609 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7610 {
7611   if (!validate_arg (arg, REAL_TYPE))
7612     return NULL_TREE;
7613
7614   /* Optimize round of constant value.  */
7615   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7616     {
7617       REAL_VALUE_TYPE x;
7618
7619       x = TREE_REAL_CST (arg);
7620       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7621         {
7622           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7623           REAL_VALUE_TYPE r;
7624
7625           real_round (&r, TYPE_MODE (type), &x);
7626           return build_real (type, r);
7627         }
7628     }
7629
7630   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7631 }
7632
7633 /* Fold function call to builtin lround, lroundf or lroundl (or the
7634    corresponding long long versions) and other rounding functions.  ARG
7635    is the argument to the call.  Return NULL_TREE if no simplification
7636    can be made.  */
7637
7638 static tree
7639 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7640 {
7641   if (!validate_arg (arg, REAL_TYPE))
7642     return NULL_TREE;
7643
7644   /* Optimize lround of constant value.  */
7645   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7646     {
7647       const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7648
7649       if (real_isfinite (&x))
7650         {
7651           tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7652           tree ftype = TREE_TYPE (arg);
7653           double_int val;
7654           REAL_VALUE_TYPE r;
7655
7656           switch (DECL_FUNCTION_CODE (fndecl))
7657             {
7658             CASE_FLT_FN (BUILT_IN_LFLOOR):
7659             CASE_FLT_FN (BUILT_IN_LLFLOOR):
7660               real_floor (&r, TYPE_MODE (ftype), &x);
7661               break;
7662
7663             CASE_FLT_FN (BUILT_IN_LCEIL):
7664             CASE_FLT_FN (BUILT_IN_LLCEIL):
7665               real_ceil (&r, TYPE_MODE (ftype), &x);
7666               break;
7667
7668             CASE_FLT_FN (BUILT_IN_LROUND):
7669             CASE_FLT_FN (BUILT_IN_LLROUND):
7670               real_round (&r, TYPE_MODE (ftype), &x);
7671               break;
7672
7673             default:
7674               gcc_unreachable ();
7675             }
7676
7677           real_to_integer2 ((HOST_WIDE_INT *)&val.low, &val.high, &r);
7678           if (double_int_fits_to_tree_p (itype, val))
7679             return double_int_to_tree (itype, val);
7680         }
7681     }
7682
7683   switch (DECL_FUNCTION_CODE (fndecl))
7684     {
7685     CASE_FLT_FN (BUILT_IN_LFLOOR):
7686     CASE_FLT_FN (BUILT_IN_LLFLOOR):
7687       /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x).  */
7688       if (tree_expr_nonnegative_p (arg))
7689         return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7690                             TREE_TYPE (TREE_TYPE (fndecl)), arg);
7691       break;
7692     default:;
7693     }
7694
7695   return fold_fixed_mathfn (loc, fndecl, arg);
7696 }
7697
7698 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
7699    and their long and long long variants (i.e. ffsl and ffsll).  ARG is
7700    the argument to the call.  Return NULL_TREE if no simplification can
7701    be made.  */
7702
7703 static tree
7704 fold_builtin_bitop (tree fndecl, tree arg)
7705 {
7706   if (!validate_arg (arg, INTEGER_TYPE))
7707     return NULL_TREE;
7708
7709   /* Optimize for constant argument.  */
7710   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7711     {
7712       HOST_WIDE_INT hi, width, result;
7713       unsigned HOST_WIDE_INT lo;
7714       tree type;
7715
7716       type = TREE_TYPE (arg);
7717       width = TYPE_PRECISION (type);
7718       lo = TREE_INT_CST_LOW (arg);
7719
7720       /* Clear all the bits that are beyond the type's precision.  */
7721       if (width > HOST_BITS_PER_WIDE_INT)
7722         {
7723           hi = TREE_INT_CST_HIGH (arg);
7724           if (width < 2 * HOST_BITS_PER_WIDE_INT)
7725             hi &= ~((HOST_WIDE_INT) (-1) >> (width - HOST_BITS_PER_WIDE_INT));
7726         }
7727       else
7728         {
7729           hi = 0;
7730           if (width < HOST_BITS_PER_WIDE_INT)
7731             lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
7732         }
7733
7734       switch (DECL_FUNCTION_CODE (fndecl))
7735         {
7736         CASE_INT_FN (BUILT_IN_FFS):
7737           if (lo != 0)
7738             result = ffs_hwi (lo);
7739           else if (hi != 0)
7740             result = HOST_BITS_PER_WIDE_INT + ffs_hwi (hi);
7741           else
7742             result = 0;
7743           break;
7744
7745         CASE_INT_FN (BUILT_IN_CLZ):
7746           if (hi != 0)
7747             result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
7748           else if (lo != 0)
7749             result = width - floor_log2 (lo) - 1;
7750           else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7751             result = width;
7752           break;
7753
7754         CASE_INT_FN (BUILT_IN_CTZ):
7755           if (lo != 0)
7756             result = ctz_hwi (lo);
7757           else if (hi != 0)
7758             result = HOST_BITS_PER_WIDE_INT + ctz_hwi (hi);
7759           else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
7760             result = width;
7761           break;
7762
7763         CASE_INT_FN (BUILT_IN_POPCOUNT):
7764           result = 0;
7765           while (lo)
7766             result++, lo &= lo - 1;
7767           while (hi)
7768             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7769           break;
7770
7771         CASE_INT_FN (BUILT_IN_PARITY):
7772           result = 0;
7773           while (lo)
7774             result++, lo &= lo - 1;
7775           while (hi)
7776             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
7777           result &= 1;
7778           break;
7779
7780         default:
7781           gcc_unreachable ();
7782         }
7783
7784       return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
7785     }
7786
7787   return NULL_TREE;
7788 }
7789
7790 /* Fold function call to builtin_bswap and the long and long long
7791    variants.  Return NULL_TREE if no simplification can be made.  */
7792 static tree
7793 fold_builtin_bswap (tree fndecl, tree arg)
7794 {
7795   if (! validate_arg (arg, INTEGER_TYPE))
7796     return NULL_TREE;
7797
7798   /* Optimize constant value.  */
7799   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
7800     {
7801       HOST_WIDE_INT hi, width, r_hi = 0;
7802       unsigned HOST_WIDE_INT lo, r_lo = 0;
7803       tree type;
7804
7805       type = TREE_TYPE (arg);
7806       width = TYPE_PRECISION (type);
7807       lo = TREE_INT_CST_LOW (arg);
7808       hi = TREE_INT_CST_HIGH (arg);
7809
7810       switch (DECL_FUNCTION_CODE (fndecl))
7811         {
7812           case BUILT_IN_BSWAP32:
7813           case BUILT_IN_BSWAP64:
7814             {
7815               int s;
7816
7817               for (s = 0; s < width; s += 8)
7818                 {
7819                   int d = width - s - 8;
7820                   unsigned HOST_WIDE_INT byte;
7821
7822                   if (s < HOST_BITS_PER_WIDE_INT)
7823                     byte = (lo >> s) & 0xff;
7824                   else
7825                     byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
7826
7827                   if (d < HOST_BITS_PER_WIDE_INT)
7828                     r_lo |= byte << d;
7829                   else
7830                     r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
7831                 }
7832             }
7833
7834             break;
7835
7836         default:
7837           gcc_unreachable ();
7838         }
7839
7840       if (width < HOST_BITS_PER_WIDE_INT)
7841         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), r_lo);
7842       else
7843         return build_int_cst_wide (TREE_TYPE (TREE_TYPE (fndecl)), r_lo, r_hi);
7844     }
7845
7846   return NULL_TREE;
7847 }
7848
7849 /* A subroutine of fold_builtin to fold the various logarithmic
7850    functions.  Return NULL_TREE if no simplification can me made.
7851    FUNC is the corresponding MPFR logarithm function.  */
7852
7853 static tree
7854 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
7855                         int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
7856 {
7857   if (validate_arg (arg, REAL_TYPE))
7858     {
7859       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7860       tree res;
7861       const enum built_in_function fcode = builtin_mathfn_code (arg);
7862
7863       /* Calculate the result when the argument is a constant.  */
7864       if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
7865         return res;
7866
7867       /* Special case, optimize logN(expN(x)) = x.  */
7868       if (flag_unsafe_math_optimizations
7869           && ((func == mpfr_log
7870                && (fcode == BUILT_IN_EXP
7871                    || fcode == BUILT_IN_EXPF
7872                    || fcode == BUILT_IN_EXPL))
7873               || (func == mpfr_log2
7874                   && (fcode == BUILT_IN_EXP2
7875                       || fcode == BUILT_IN_EXP2F
7876                       || fcode == BUILT_IN_EXP2L))
7877               || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
7878         return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
7879
7880       /* Optimize logN(func()) for various exponential functions.  We
7881          want to determine the value "x" and the power "exponent" in
7882          order to transform logN(x**exponent) into exponent*logN(x).  */
7883       if (flag_unsafe_math_optimizations)
7884         {
7885           tree exponent = 0, x = 0;
7886
7887           switch (fcode)
7888           {
7889           CASE_FLT_FN (BUILT_IN_EXP):
7890             /* Prepare to do logN(exp(exponent) -> exponent*logN(e).  */
7891             x = build_real (type, real_value_truncate (TYPE_MODE (type),
7892                                                        dconst_e ()));
7893             exponent = CALL_EXPR_ARG (arg, 0);
7894             break;
7895           CASE_FLT_FN (BUILT_IN_EXP2):
7896             /* Prepare to do logN(exp2(exponent) -> exponent*logN(2).  */
7897             x = build_real (type, dconst2);
7898             exponent = CALL_EXPR_ARG (arg, 0);
7899             break;
7900           CASE_FLT_FN (BUILT_IN_EXP10):
7901           CASE_FLT_FN (BUILT_IN_POW10):
7902             /* Prepare to do logN(exp10(exponent) -> exponent*logN(10).  */
7903             {
7904               REAL_VALUE_TYPE dconst10;
7905               real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
7906               x = build_real (type, dconst10);
7907             }
7908             exponent = CALL_EXPR_ARG (arg, 0);
7909             break;
7910           CASE_FLT_FN (BUILT_IN_SQRT):
7911             /* Prepare to do logN(sqrt(x) -> 0.5*logN(x).  */
7912             x = CALL_EXPR_ARG (arg, 0);
7913             exponent = build_real (type, dconsthalf);
7914             break;
7915           CASE_FLT_FN (BUILT_IN_CBRT):
7916             /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x).  */
7917             x = CALL_EXPR_ARG (arg, 0);
7918             exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
7919                                                               dconst_third ()));
7920             break;
7921           CASE_FLT_FN (BUILT_IN_POW):
7922             /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x).  */
7923             x = CALL_EXPR_ARG (arg, 0);
7924             exponent = CALL_EXPR_ARG (arg, 1);
7925             break;
7926           default:
7927             break;
7928           }
7929
7930           /* Now perform the optimization.  */
7931           if (x && exponent)
7932             {
7933               tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
7934               return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
7935             }
7936         }
7937     }
7938
7939   return NULL_TREE;
7940 }
7941
7942 /* Fold a builtin function call to hypot, hypotf, or hypotl.  Return
7943    NULL_TREE if no simplification can be made.  */
7944
7945 static tree
7946 fold_builtin_hypot (location_t loc, tree fndecl,
7947                     tree arg0, tree arg1, tree type)
7948 {
7949   tree res, narg0, narg1;
7950
7951   if (!validate_arg (arg0, REAL_TYPE)
7952       || !validate_arg (arg1, REAL_TYPE))
7953     return NULL_TREE;
7954
7955   /* Calculate the result when the argument is a constant.  */
7956   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
7957     return res;
7958
7959   /* If either argument to hypot has a negate or abs, strip that off.
7960      E.g. hypot(-x,fabs(y)) -> hypot(x,y).  */
7961   narg0 = fold_strip_sign_ops (arg0);
7962   narg1 = fold_strip_sign_ops (arg1);
7963   if (narg0 || narg1)
7964     {
7965       return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
7966                               narg1 ? narg1 : arg1);
7967     }
7968
7969   /* If either argument is zero, hypot is fabs of the other.  */
7970   if (real_zerop (arg0))
7971     return fold_build1_loc (loc, ABS_EXPR, type, arg1);
7972   else if (real_zerop (arg1))
7973     return fold_build1_loc (loc, ABS_EXPR, type, arg0);
7974
7975   /* hypot(x,x) -> fabs(x)*sqrt(2).  */
7976   if (flag_unsafe_math_optimizations
7977       && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
7978     {
7979       const REAL_VALUE_TYPE sqrt2_trunc
7980         = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7981       return fold_build2_loc (loc, MULT_EXPR, type,
7982                           fold_build1_loc (loc, ABS_EXPR, type, arg0),
7983                           build_real (type, sqrt2_trunc));
7984     }
7985
7986   return NULL_TREE;
7987 }
7988
7989
7990 /* Fold a builtin function call to pow, powf, or powl.  Return
7991    NULL_TREE if no simplification can be made.  */
7992 static tree
7993 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
7994 {
7995   tree res;
7996
7997   if (!validate_arg (arg0, REAL_TYPE)
7998        || !validate_arg (arg1, REAL_TYPE))
7999     return NULL_TREE;
8000
8001   /* Calculate the result when the argument is a constant.  */
8002   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8003     return res;
8004
8005   /* Optimize pow(1.0,y) = 1.0.  */
8006   if (real_onep (arg0))
8007     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8008
8009   if (TREE_CODE (arg1) == REAL_CST
8010       && !TREE_OVERFLOW (arg1))
8011     {
8012       REAL_VALUE_TYPE cint;
8013       REAL_VALUE_TYPE c;
8014       HOST_WIDE_INT n;
8015
8016       c = TREE_REAL_CST (arg1);
8017
8018       /* Optimize pow(x,0.0) = 1.0.  */
8019       if (REAL_VALUES_EQUAL (c, dconst0))
8020         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8021                                  arg0);
8022
8023       /* Optimize pow(x,1.0) = x.  */
8024       if (REAL_VALUES_EQUAL (c, dconst1))
8025         return arg0;
8026
8027       /* Optimize pow(x,-1.0) = 1.0/x.  */
8028       if (REAL_VALUES_EQUAL (c, dconstm1))
8029         return fold_build2_loc (loc, RDIV_EXPR, type,
8030                             build_real (type, dconst1), arg0);
8031
8032       /* Optimize pow(x,0.5) = sqrt(x).  */
8033       if (flag_unsafe_math_optimizations
8034           && REAL_VALUES_EQUAL (c, dconsthalf))
8035         {
8036           tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8037
8038           if (sqrtfn != NULL_TREE)
8039             return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8040         }
8041
8042       /* Optimize pow(x,1.0/3.0) = cbrt(x).  */
8043       if (flag_unsafe_math_optimizations)
8044         {
8045           const REAL_VALUE_TYPE dconstroot
8046             = real_value_truncate (TYPE_MODE (type), dconst_third ());
8047
8048           if (REAL_VALUES_EQUAL (c, dconstroot))
8049             {
8050               tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8051               if (cbrtfn != NULL_TREE)
8052                 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8053             }
8054         }
8055
8056       /* Check for an integer exponent.  */
8057       n = real_to_integer (&c);
8058       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8059       if (real_identical (&c, &cint))
8060         {
8061           /* Attempt to evaluate pow at compile-time, unless this should
8062              raise an exception.  */
8063           if (TREE_CODE (arg0) == REAL_CST
8064               && !TREE_OVERFLOW (arg0)
8065               && (n > 0
8066                   || (!flag_trapping_math && !flag_errno_math)
8067                   || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8068             {
8069               REAL_VALUE_TYPE x;
8070               bool inexact;
8071
8072               x = TREE_REAL_CST (arg0);
8073               inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8074               if (flag_unsafe_math_optimizations || !inexact)
8075                 return build_real (type, x);
8076             }
8077
8078           /* Strip sign ops from even integer powers.  */
8079           if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8080             {
8081               tree narg0 = fold_strip_sign_ops (arg0);
8082               if (narg0)
8083                 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8084             }
8085         }
8086     }
8087
8088   if (flag_unsafe_math_optimizations)
8089     {
8090       const enum built_in_function fcode = builtin_mathfn_code (arg0);
8091
8092       /* Optimize pow(expN(x),y) = expN(x*y).  */
8093       if (BUILTIN_EXPONENT_P (fcode))
8094         {
8095           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8096           tree arg = CALL_EXPR_ARG (arg0, 0);
8097           arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8098           return build_call_expr_loc (loc, expfn, 1, arg);
8099         }
8100
8101       /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
8102       if (BUILTIN_SQRT_P (fcode))
8103         {
8104           tree narg0 = CALL_EXPR_ARG (arg0, 0);
8105           tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8106                                     build_real (type, dconsthalf));
8107           return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8108         }
8109
8110       /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative.  */
8111       if (BUILTIN_CBRT_P (fcode))
8112         {
8113           tree arg = CALL_EXPR_ARG (arg0, 0);
8114           if (tree_expr_nonnegative_p (arg))
8115             {
8116               const REAL_VALUE_TYPE dconstroot
8117                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8118               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8119                                         build_real (type, dconstroot));
8120               return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8121             }
8122         }
8123
8124       /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative.  */
8125       if (fcode == BUILT_IN_POW
8126           || fcode == BUILT_IN_POWF
8127           || fcode == BUILT_IN_POWL)
8128         {
8129           tree arg00 = CALL_EXPR_ARG (arg0, 0);
8130           if (tree_expr_nonnegative_p (arg00))
8131             {
8132               tree arg01 = CALL_EXPR_ARG (arg0, 1);
8133               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8134               return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8135             }
8136         }
8137     }
8138
8139   return NULL_TREE;
8140 }
8141
8142 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8143    Return NULL_TREE if no simplification can be made.  */
8144 static tree
8145 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8146                    tree arg0, tree arg1, tree type)
8147 {
8148   if (!validate_arg (arg0, REAL_TYPE)
8149       || !validate_arg (arg1, INTEGER_TYPE))
8150     return NULL_TREE;
8151
8152   /* Optimize pow(1.0,y) = 1.0.  */
8153   if (real_onep (arg0))
8154     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8155
8156   if (host_integerp (arg1, 0))
8157     {
8158       HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8159
8160       /* Evaluate powi at compile-time.  */
8161       if (TREE_CODE (arg0) == REAL_CST
8162           && !TREE_OVERFLOW (arg0))
8163         {
8164           REAL_VALUE_TYPE x;
8165           x = TREE_REAL_CST (arg0);
8166           real_powi (&x, TYPE_MODE (type), &x, c);
8167           return build_real (type, x);
8168         }
8169
8170       /* Optimize pow(x,0) = 1.0.  */
8171       if (c == 0)
8172         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8173                                  arg0);
8174
8175       /* Optimize pow(x,1) = x.  */
8176       if (c == 1)
8177         return arg0;
8178
8179       /* Optimize pow(x,-1) = 1.0/x.  */
8180       if (c == -1)
8181         return fold_build2_loc (loc, RDIV_EXPR, type,
8182                            build_real (type, dconst1), arg0);
8183     }
8184
8185   return NULL_TREE;
8186 }
8187
8188 /* A subroutine of fold_builtin to fold the various exponent
8189    functions.  Return NULL_TREE if no simplification can be made.
8190    FUNC is the corresponding MPFR exponent function.  */
8191
8192 static tree
8193 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8194                        int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8195 {
8196   if (validate_arg (arg, REAL_TYPE))
8197     {
8198       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8199       tree res;
8200
8201       /* Calculate the result when the argument is a constant.  */
8202       if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8203         return res;
8204
8205       /* Optimize expN(logN(x)) = x.  */
8206       if (flag_unsafe_math_optimizations)
8207         {
8208           const enum built_in_function fcode = builtin_mathfn_code (arg);
8209
8210           if ((func == mpfr_exp
8211                && (fcode == BUILT_IN_LOG
8212                    || fcode == BUILT_IN_LOGF
8213                    || fcode == BUILT_IN_LOGL))
8214               || (func == mpfr_exp2
8215                   && (fcode == BUILT_IN_LOG2
8216                       || fcode == BUILT_IN_LOG2F
8217                       || fcode == BUILT_IN_LOG2L))
8218               || (func == mpfr_exp10
8219                   && (fcode == BUILT_IN_LOG10
8220                       || fcode == BUILT_IN_LOG10F
8221                       || fcode == BUILT_IN_LOG10L)))
8222             return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8223         }
8224     }
8225
8226   return NULL_TREE;
8227 }
8228
8229 /* Return true if VAR is a VAR_DECL or a component thereof.  */
8230
8231 static bool
8232 var_decl_component_p (tree var)
8233 {
8234   tree inner = var;
8235   while (handled_component_p (inner))
8236     inner = TREE_OPERAND (inner, 0);
8237   return SSA_VAR_P (inner);
8238 }
8239
8240 /* Fold function call to builtin memset.  Return
8241    NULL_TREE if no simplification can be made.  */
8242
8243 static tree
8244 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8245                      tree type, bool ignore)
8246 {
8247   tree var, ret, etype;
8248   unsigned HOST_WIDE_INT length, cval;
8249
8250   if (! validate_arg (dest, POINTER_TYPE)
8251       || ! validate_arg (c, INTEGER_TYPE)
8252       || ! validate_arg (len, INTEGER_TYPE))
8253     return NULL_TREE;
8254
8255   if (! host_integerp (len, 1))
8256     return NULL_TREE;
8257
8258   /* If the LEN parameter is zero, return DEST.  */
8259   if (integer_zerop (len))
8260     return omit_one_operand_loc (loc, type, dest, c);
8261
8262   if (! host_integerp (c, 1) || TREE_SIDE_EFFECTS (dest))
8263     return NULL_TREE;
8264
8265   var = dest;
8266   STRIP_NOPS (var);
8267   if (TREE_CODE (var) != ADDR_EXPR)
8268     return NULL_TREE;
8269
8270   var = TREE_OPERAND (var, 0);
8271   if (TREE_THIS_VOLATILE (var))
8272     return NULL_TREE;
8273
8274   etype = TREE_TYPE (var);
8275   if (TREE_CODE (etype) == ARRAY_TYPE)
8276     etype = TREE_TYPE (etype);
8277
8278   if (!INTEGRAL_TYPE_P (etype)
8279       && !POINTER_TYPE_P (etype))
8280     return NULL_TREE;
8281
8282   if (! var_decl_component_p (var))
8283     return NULL_TREE;
8284
8285   length = tree_low_cst (len, 1);
8286   if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8287       || get_pointer_alignment (dest, BIGGEST_ALIGNMENT) / BITS_PER_UNIT
8288          < length)
8289     return NULL_TREE;
8290
8291   if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8292     return NULL_TREE;
8293
8294   if (integer_zerop (c))
8295     cval = 0;
8296   else
8297     {
8298       if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8299         return NULL_TREE;
8300
8301       cval = tree_low_cst (c, 1);
8302       cval &= 0xff;
8303       cval |= cval << 8;
8304       cval |= cval << 16;
8305       cval |= (cval << 31) << 1;
8306     }
8307
8308   ret = build_int_cst_type (etype, cval);
8309   var = build_fold_indirect_ref_loc (loc,
8310                                  fold_convert_loc (loc,
8311                                                    build_pointer_type (etype),
8312                                                    dest));
8313   ret = build2 (MODIFY_EXPR, etype, var, ret);
8314   if (ignore)
8315     return ret;
8316
8317   return omit_one_operand_loc (loc, type, dest, ret);
8318 }
8319
8320 /* Fold function call to builtin memset.  Return
8321    NULL_TREE if no simplification can be made.  */
8322
8323 static tree
8324 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8325 {
8326   if (! validate_arg (dest, POINTER_TYPE)
8327       || ! validate_arg (size, INTEGER_TYPE))
8328     return NULL_TREE;
8329
8330   if (!ignore)
8331     return NULL_TREE;
8332
8333   /* New argument list transforming bzero(ptr x, int y) to
8334      memset(ptr x, int 0, size_t y).   This is done this way
8335      so that if it isn't expanded inline, we fallback to
8336      calling bzero instead of memset.  */
8337
8338   return fold_builtin_memset (loc, dest, integer_zero_node,
8339                               fold_convert_loc (loc, sizetype, size),
8340                               void_type_node, ignore);
8341 }
8342
8343 /* Fold function call to builtin mem{{,p}cpy,move}.  Return
8344    NULL_TREE if no simplification can be made.
8345    If ENDP is 0, return DEST (like memcpy).
8346    If ENDP is 1, return DEST+LEN (like mempcpy).
8347    If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8348    If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8349    (memmove).   */
8350
8351 static tree
8352 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8353                         tree len, tree type, bool ignore, int endp)
8354 {
8355   tree destvar, srcvar, expr;
8356
8357   if (! validate_arg (dest, POINTER_TYPE)
8358       || ! validate_arg (src, POINTER_TYPE)
8359       || ! validate_arg (len, INTEGER_TYPE))
8360     return NULL_TREE;
8361
8362   /* If the LEN parameter is zero, return DEST.  */
8363   if (integer_zerop (len))
8364     return omit_one_operand_loc (loc, type, dest, src);
8365
8366   /* If SRC and DEST are the same (and not volatile), return
8367      DEST{,+LEN,+LEN-1}.  */
8368   if (operand_equal_p (src, dest, 0))
8369     expr = len;
8370   else
8371     {
8372       tree srctype, desttype;
8373       unsigned int src_align, dest_align;
8374       tree off0;
8375
8376       if (endp == 3)
8377         {
8378           src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8379           dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8380
8381           /* Both DEST and SRC must be pointer types.
8382              ??? This is what old code did.  Is the testing for pointer types
8383              really mandatory?
8384
8385              If either SRC is readonly or length is 1, we can use memcpy.  */
8386           if (!dest_align || !src_align)
8387             return NULL_TREE;
8388           if (readonly_data_expr (src)
8389               || (host_integerp (len, 1)
8390                   && (MIN (src_align, dest_align) / BITS_PER_UNIT
8391                       >= (unsigned HOST_WIDE_INT) tree_low_cst (len, 1))))
8392             {
8393               tree fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8394               if (!fn)
8395                 return NULL_TREE;
8396               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8397             }
8398
8399           /* If *src and *dest can't overlap, optimize into memcpy as well.  */
8400           if (TREE_CODE (src) == ADDR_EXPR
8401               && TREE_CODE (dest) == ADDR_EXPR)
8402             {
8403               tree src_base, dest_base, fn;
8404               HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8405               HOST_WIDE_INT size = -1;
8406               HOST_WIDE_INT maxsize = -1;
8407
8408               srcvar = TREE_OPERAND (src, 0);
8409               src_base = get_ref_base_and_extent (srcvar, &src_offset,
8410                                                   &size, &maxsize);
8411               destvar = TREE_OPERAND (dest, 0);
8412               dest_base = get_ref_base_and_extent (destvar, &dest_offset,
8413                                                    &size, &maxsize);
8414               if (host_integerp (len, 1))
8415                 maxsize = tree_low_cst (len, 1);
8416               else
8417                 maxsize = -1;
8418               src_offset /= BITS_PER_UNIT;
8419               dest_offset /= BITS_PER_UNIT;
8420               if (SSA_VAR_P (src_base)
8421                   && SSA_VAR_P (dest_base))
8422                 {
8423                   if (operand_equal_p (src_base, dest_base, 0)
8424                       && ranges_overlap_p (src_offset, maxsize,
8425                                            dest_offset, maxsize))
8426                     return NULL_TREE;
8427                 }
8428               else if (TREE_CODE (src_base) == MEM_REF
8429                        && TREE_CODE (dest_base) == MEM_REF)
8430                 {
8431                   double_int off;
8432                   if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8433                                          TREE_OPERAND (dest_base, 0), 0))
8434                     return NULL_TREE;
8435                   off = double_int_add (mem_ref_offset (src_base),
8436                                         shwi_to_double_int (src_offset));
8437                   if (!double_int_fits_in_shwi_p (off))
8438                     return NULL_TREE;
8439                   src_offset = off.low;
8440                   off = double_int_add (mem_ref_offset (dest_base),
8441                                         shwi_to_double_int (dest_offset));
8442                   if (!double_int_fits_in_shwi_p (off))
8443                     return NULL_TREE;
8444                   dest_offset = off.low;
8445                   if (ranges_overlap_p (src_offset, maxsize,
8446                                         dest_offset, maxsize))
8447                     return NULL_TREE;
8448                 }
8449               else
8450                 return NULL_TREE;
8451
8452               fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8453               if (!fn)
8454                 return NULL_TREE;
8455               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8456             }
8457
8458           /* If the destination and source do not alias optimize into
8459              memcpy as well.  */
8460           if ((is_gimple_min_invariant (dest)
8461                || TREE_CODE (dest) == SSA_NAME)
8462               && (is_gimple_min_invariant (src)
8463                   || TREE_CODE (src) == SSA_NAME))
8464             {
8465               ao_ref destr, srcr;
8466               ao_ref_init_from_ptr_and_size (&destr, dest, len);
8467               ao_ref_init_from_ptr_and_size (&srcr, src, len);
8468               if (!refs_may_alias_p_1 (&destr, &srcr, false))
8469                 {
8470                   tree fn;
8471                   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8472                   if (!fn)
8473                     return NULL_TREE;
8474                   return build_call_expr_loc (loc, fn, 3, dest, src, len);
8475                 }
8476             }
8477
8478           return NULL_TREE;
8479         }
8480
8481       if (!host_integerp (len, 0))
8482         return NULL_TREE;
8483       /* FIXME:
8484          This logic lose for arguments like (type *)malloc (sizeof (type)),
8485          since we strip the casts of up to VOID return value from malloc.
8486          Perhaps we ought to inherit type from non-VOID argument here?  */
8487       STRIP_NOPS (src);
8488       STRIP_NOPS (dest);
8489       /* As we fold (void *)(p + CST) to (void *)p + CST undo this here.  */
8490       if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8491         {
8492           tree tem = TREE_OPERAND (src, 0);
8493           STRIP_NOPS (tem);
8494           if (tem != TREE_OPERAND (src, 0))
8495             src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8496         }
8497       if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8498         {
8499           tree tem = TREE_OPERAND (dest, 0);
8500           STRIP_NOPS (tem);
8501           if (tem != TREE_OPERAND (dest, 0))
8502             dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8503         }
8504       srctype = TREE_TYPE (TREE_TYPE (src));
8505       if (srctype
8506           && TREE_CODE (srctype) == ARRAY_TYPE
8507           && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8508         {
8509           srctype = TREE_TYPE (srctype);
8510           STRIP_NOPS (src);
8511           src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8512         }
8513       desttype = TREE_TYPE (TREE_TYPE (dest));
8514       if (desttype
8515           && TREE_CODE (desttype) == ARRAY_TYPE
8516           && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8517         {
8518           desttype = TREE_TYPE (desttype);
8519           STRIP_NOPS (dest);
8520           dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8521         }
8522       if (!srctype || !desttype
8523           || TREE_ADDRESSABLE (srctype)
8524           || TREE_ADDRESSABLE (desttype)
8525           || !TYPE_SIZE_UNIT (srctype)
8526           || !TYPE_SIZE_UNIT (desttype)
8527           || TREE_CODE (TYPE_SIZE_UNIT (srctype)) != INTEGER_CST
8528           || TREE_CODE (TYPE_SIZE_UNIT (desttype)) != INTEGER_CST)
8529         return NULL_TREE;
8530
8531       src_align = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
8532       dest_align = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
8533       if (dest_align < TYPE_ALIGN (desttype)
8534           || src_align < TYPE_ALIGN (srctype))
8535         return NULL_TREE;
8536
8537       if (!ignore)
8538         dest = builtin_save_expr (dest);
8539
8540       /* Build accesses at offset zero with a ref-all character type.  */
8541       off0 = build_int_cst (build_pointer_type_for_mode (char_type_node,
8542                                                          ptr_mode, true), 0);
8543
8544       destvar = dest;
8545       STRIP_NOPS (destvar);
8546       if (TREE_CODE (destvar) == ADDR_EXPR
8547           && var_decl_component_p (TREE_OPERAND (destvar, 0))
8548           && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8549         destvar = fold_build2 (MEM_REF, desttype, destvar, off0);
8550       else
8551         destvar = NULL_TREE;
8552
8553       srcvar = src;
8554       STRIP_NOPS (srcvar);
8555       if (TREE_CODE (srcvar) == ADDR_EXPR
8556           && var_decl_component_p (TREE_OPERAND (srcvar, 0))
8557           && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8558         {
8559           if (!destvar
8560               || src_align >= TYPE_ALIGN (desttype))
8561             srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype,
8562                                   srcvar, off0);
8563           else if (!STRICT_ALIGNMENT)
8564             {
8565               srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8566                                             src_align);
8567               srcvar = fold_build2 (MEM_REF, srctype, srcvar, off0);
8568             }
8569           else
8570             srcvar = NULL_TREE;
8571         }
8572       else
8573         srcvar = NULL_TREE;
8574
8575       if (srcvar == NULL_TREE && destvar == NULL_TREE)
8576         return NULL_TREE;
8577
8578       if (srcvar == NULL_TREE)
8579         {
8580           STRIP_NOPS (src);
8581           if (src_align >= TYPE_ALIGN (desttype))
8582             srcvar = fold_build2 (MEM_REF, desttype, src, off0);
8583           else
8584             {
8585               if (STRICT_ALIGNMENT)
8586                 return NULL_TREE;
8587               srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8588                                             src_align);
8589               srcvar = fold_build2 (MEM_REF, srctype, src, off0);
8590             }
8591         }
8592       else if (destvar == NULL_TREE)
8593         {
8594           STRIP_NOPS (dest);
8595           if (dest_align >= TYPE_ALIGN (srctype))
8596             destvar = fold_build2 (MEM_REF, srctype, dest, off0);
8597           else
8598             {
8599               if (STRICT_ALIGNMENT)
8600                 return NULL_TREE;
8601               desttype = build_aligned_type (TYPE_MAIN_VARIANT (srctype),
8602                                              dest_align);
8603               destvar = fold_build2 (MEM_REF, desttype, dest, off0);
8604             }
8605         }
8606
8607       expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, srcvar);
8608     }
8609
8610   if (ignore)
8611     return expr;
8612
8613   if (endp == 0 || endp == 3)
8614     return omit_one_operand_loc (loc, type, dest, expr);
8615
8616   if (expr == len)
8617     expr = NULL_TREE;
8618
8619   if (endp == 2)
8620     len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
8621                        ssize_int (1));
8622
8623   len = fold_convert_loc (loc, sizetype, len);
8624   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8625   dest = fold_convert_loc (loc, type, dest);
8626   if (expr)
8627     dest = omit_one_operand_loc (loc, type, dest, expr);
8628   return dest;
8629 }
8630
8631 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8632    If LEN is not NULL, it represents the length of the string to be
8633    copied.  Return NULL_TREE if no simplification can be made.  */
8634
8635 tree
8636 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
8637 {
8638   tree fn;
8639
8640   if (!validate_arg (dest, POINTER_TYPE)
8641       || !validate_arg (src, POINTER_TYPE))
8642     return NULL_TREE;
8643
8644   /* If SRC and DEST are the same (and not volatile), return DEST.  */
8645   if (operand_equal_p (src, dest, 0))
8646     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
8647
8648   if (optimize_function_for_size_p (cfun))
8649     return NULL_TREE;
8650
8651   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8652   if (!fn)
8653     return NULL_TREE;
8654
8655   if (!len)
8656     {
8657       len = c_strlen (src, 1);
8658       if (! len || TREE_SIDE_EFFECTS (len))
8659         return NULL_TREE;
8660     }
8661
8662   len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8663   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8664                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8665 }
8666
8667 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
8668    Return NULL_TREE if no simplification can be made.  */
8669
8670 static tree
8671 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
8672 {
8673   tree fn, len, lenp1, call, type;
8674
8675   if (!validate_arg (dest, POINTER_TYPE)
8676       || !validate_arg (src, POINTER_TYPE))
8677     return NULL_TREE;
8678
8679   len = c_strlen (src, 1);
8680   if (!len
8681       || TREE_CODE (len) != INTEGER_CST)
8682     return NULL_TREE;
8683
8684   if (optimize_function_for_size_p (cfun)
8685       /* If length is zero it's small enough.  */
8686       && !integer_zerop (len))
8687     return NULL_TREE;
8688
8689   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8690   if (!fn)
8691     return NULL_TREE;
8692
8693   lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
8694   /* We use dest twice in building our expression.  Save it from
8695      multiple expansions.  */
8696   dest = builtin_save_expr (dest);
8697   call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
8698
8699   type = TREE_TYPE (TREE_TYPE (fndecl));
8700   len = fold_convert_loc (loc, sizetype, len);
8701   dest = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
8702   dest = fold_convert_loc (loc, type, dest);
8703   dest = omit_one_operand_loc (loc, type, dest, call);
8704   return dest;
8705 }
8706
8707 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
8708    If SLEN is not NULL, it represents the length of the source string.
8709    Return NULL_TREE if no simplification can be made.  */
8710
8711 tree
8712 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
8713                       tree src, tree len, tree slen)
8714 {
8715   tree fn;
8716
8717   if (!validate_arg (dest, POINTER_TYPE)
8718       || !validate_arg (src, POINTER_TYPE)
8719       || !validate_arg (len, INTEGER_TYPE))
8720     return NULL_TREE;
8721
8722   /* If the LEN parameter is zero, return DEST.  */
8723   if (integer_zerop (len))
8724     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
8725
8726   /* We can't compare slen with len as constants below if len is not a
8727      constant.  */
8728   if (len == 0 || TREE_CODE (len) != INTEGER_CST)
8729     return NULL_TREE;
8730
8731   if (!slen)
8732     slen = c_strlen (src, 1);
8733
8734   /* Now, we must be passed a constant src ptr parameter.  */
8735   if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
8736     return NULL_TREE;
8737
8738   slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
8739
8740   /* We do not support simplification of this case, though we do
8741      support it when expanding trees into RTL.  */
8742   /* FIXME: generate a call to __builtin_memset.  */
8743   if (tree_int_cst_lt (slen, len))
8744     return NULL_TREE;
8745
8746   /* OK transform into builtin memcpy.  */
8747   fn = implicit_built_in_decls[BUILT_IN_MEMCPY];
8748   if (!fn)
8749     return NULL_TREE;
8750   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
8751                            build_call_expr_loc (loc, fn, 3, dest, src, len));
8752 }
8753
8754 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
8755    arguments to the call, and TYPE is its return type.
8756    Return NULL_TREE if no simplification can be made.  */
8757
8758 static tree
8759 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
8760 {
8761   if (!validate_arg (arg1, POINTER_TYPE)
8762       || !validate_arg (arg2, INTEGER_TYPE)
8763       || !validate_arg (len, INTEGER_TYPE))
8764     return NULL_TREE;
8765   else
8766     {
8767       const char *p1;
8768
8769       if (TREE_CODE (arg2) != INTEGER_CST
8770           || !host_integerp (len, 1))
8771         return NULL_TREE;
8772
8773       p1 = c_getstr (arg1);
8774       if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
8775         {
8776           char c;
8777           const char *r;
8778           tree tem;
8779
8780           if (target_char_cast (arg2, &c))
8781             return NULL_TREE;
8782
8783           r = (char *) memchr (p1, c, tree_low_cst (len, 1));
8784
8785           if (r == NULL)
8786             return build_int_cst (TREE_TYPE (arg1), 0);
8787
8788           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (arg1), arg1,
8789                              size_int (r - p1));
8790           return fold_convert_loc (loc, type, tem);
8791         }
8792       return NULL_TREE;
8793     }
8794 }
8795
8796 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
8797    Return NULL_TREE if no simplification can be made.  */
8798
8799 static tree
8800 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
8801 {
8802   const char *p1, *p2;
8803
8804   if (!validate_arg (arg1, POINTER_TYPE)
8805       || !validate_arg (arg2, POINTER_TYPE)
8806       || !validate_arg (len, INTEGER_TYPE))
8807     return NULL_TREE;
8808
8809   /* If the LEN parameter is zero, return zero.  */
8810   if (integer_zerop (len))
8811     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8812                               arg1, arg2);
8813
8814   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8815   if (operand_equal_p (arg1, arg2, 0))
8816     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8817
8818   p1 = c_getstr (arg1);
8819   p2 = c_getstr (arg2);
8820
8821   /* If all arguments are constant, and the value of len is not greater
8822      than the lengths of arg1 and arg2, evaluate at compile-time.  */
8823   if (host_integerp (len, 1) && p1 && p2
8824       && compare_tree_int (len, strlen (p1) + 1) <= 0
8825       && compare_tree_int (len, strlen (p2) + 1) <= 0)
8826     {
8827       const int r = memcmp (p1, p2, tree_low_cst (len, 1));
8828
8829       if (r > 0)
8830         return integer_one_node;
8831       else if (r < 0)
8832         return integer_minus_one_node;
8833       else
8834         return integer_zero_node;
8835     }
8836
8837   /* If len parameter is one, return an expression corresponding to
8838      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
8839   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
8840     {
8841       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8842       tree cst_uchar_ptr_node
8843         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8844
8845       tree ind1
8846         = fold_convert_loc (loc, integer_type_node,
8847                             build1 (INDIRECT_REF, cst_uchar_node,
8848                                     fold_convert_loc (loc,
8849                                                       cst_uchar_ptr_node,
8850                                                       arg1)));
8851       tree ind2
8852         = fold_convert_loc (loc, integer_type_node,
8853                             build1 (INDIRECT_REF, cst_uchar_node,
8854                                     fold_convert_loc (loc,
8855                                                       cst_uchar_ptr_node,
8856                                                       arg2)));
8857       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
8858     }
8859
8860   return NULL_TREE;
8861 }
8862
8863 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
8864    Return NULL_TREE if no simplification can be made.  */
8865
8866 static tree
8867 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
8868 {
8869   const char *p1, *p2;
8870
8871   if (!validate_arg (arg1, POINTER_TYPE)
8872       || !validate_arg (arg2, POINTER_TYPE))
8873     return NULL_TREE;
8874
8875   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8876   if (operand_equal_p (arg1, arg2, 0))
8877     return integer_zero_node;
8878
8879   p1 = c_getstr (arg1);
8880   p2 = c_getstr (arg2);
8881
8882   if (p1 && p2)
8883     {
8884       const int i = strcmp (p1, p2);
8885       if (i < 0)
8886         return integer_minus_one_node;
8887       else if (i > 0)
8888         return integer_one_node;
8889       else
8890         return integer_zero_node;
8891     }
8892
8893   /* If the second arg is "", return *(const unsigned char*)arg1.  */
8894   if (p2 && *p2 == '\0')
8895     {
8896       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8897       tree cst_uchar_ptr_node
8898         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8899
8900       return fold_convert_loc (loc, integer_type_node,
8901                                build1 (INDIRECT_REF, cst_uchar_node,
8902                                        fold_convert_loc (loc,
8903                                                          cst_uchar_ptr_node,
8904                                                          arg1)));
8905     }
8906
8907   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
8908   if (p1 && *p1 == '\0')
8909     {
8910       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8911       tree cst_uchar_ptr_node
8912         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8913
8914       tree temp
8915         = fold_convert_loc (loc, integer_type_node,
8916                             build1 (INDIRECT_REF, cst_uchar_node,
8917                                     fold_convert_loc (loc,
8918                                                       cst_uchar_ptr_node,
8919                                                       arg2)));
8920       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8921     }
8922
8923   return NULL_TREE;
8924 }
8925
8926 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
8927    Return NULL_TREE if no simplification can be made.  */
8928
8929 static tree
8930 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
8931 {
8932   const char *p1, *p2;
8933
8934   if (!validate_arg (arg1, POINTER_TYPE)
8935       || !validate_arg (arg2, POINTER_TYPE)
8936       || !validate_arg (len, INTEGER_TYPE))
8937     return NULL_TREE;
8938
8939   /* If the LEN parameter is zero, return zero.  */
8940   if (integer_zerop (len))
8941     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
8942                               arg1, arg2);
8943
8944   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
8945   if (operand_equal_p (arg1, arg2, 0))
8946     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
8947
8948   p1 = c_getstr (arg1);
8949   p2 = c_getstr (arg2);
8950
8951   if (host_integerp (len, 1) && p1 && p2)
8952     {
8953       const int i = strncmp (p1, p2, tree_low_cst (len, 1));
8954       if (i > 0)
8955         return integer_one_node;
8956       else if (i < 0)
8957         return integer_minus_one_node;
8958       else
8959         return integer_zero_node;
8960     }
8961
8962   /* If the second arg is "", and the length is greater than zero,
8963      return *(const unsigned char*)arg1.  */
8964   if (p2 && *p2 == '\0'
8965       && TREE_CODE (len) == INTEGER_CST
8966       && tree_int_cst_sgn (len) == 1)
8967     {
8968       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8969       tree cst_uchar_ptr_node
8970         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8971
8972       return fold_convert_loc (loc, integer_type_node,
8973                                build1 (INDIRECT_REF, cst_uchar_node,
8974                                        fold_convert_loc (loc,
8975                                                          cst_uchar_ptr_node,
8976                                                          arg1)));
8977     }
8978
8979   /* If the first arg is "", and the length is greater than zero,
8980      return -*(const unsigned char*)arg2.  */
8981   if (p1 && *p1 == '\0'
8982       && TREE_CODE (len) == INTEGER_CST
8983       && tree_int_cst_sgn (len) == 1)
8984     {
8985       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
8986       tree cst_uchar_ptr_node
8987         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
8988
8989       tree temp = fold_convert_loc (loc, integer_type_node,
8990                                     build1 (INDIRECT_REF, cst_uchar_node,
8991                                             fold_convert_loc (loc,
8992                                                               cst_uchar_ptr_node,
8993                                                               arg2)));
8994       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
8995     }
8996
8997   /* If len parameter is one, return an expression corresponding to
8998      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
8999   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9000     {
9001       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9002       tree cst_uchar_ptr_node
9003         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9004
9005       tree ind1 = fold_convert_loc (loc, integer_type_node,
9006                                     build1 (INDIRECT_REF, cst_uchar_node,
9007                                             fold_convert_loc (loc,
9008                                                               cst_uchar_ptr_node,
9009                                                               arg1)));
9010       tree ind2 = fold_convert_loc (loc, integer_type_node,
9011                                     build1 (INDIRECT_REF, cst_uchar_node,
9012                                             fold_convert_loc (loc,
9013                                                               cst_uchar_ptr_node,
9014                                                               arg2)));
9015       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9016     }
9017
9018   return NULL_TREE;
9019 }
9020
9021 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9022    ARG.  Return NULL_TREE if no simplification can be made.  */
9023
9024 static tree
9025 fold_builtin_signbit (location_t loc, tree arg, tree type)
9026 {
9027   tree temp;
9028
9029   if (!validate_arg (arg, REAL_TYPE))
9030     return NULL_TREE;
9031
9032   /* If ARG is a compile-time constant, determine the result.  */
9033   if (TREE_CODE (arg) == REAL_CST
9034       && !TREE_OVERFLOW (arg))
9035     {
9036       REAL_VALUE_TYPE c;
9037
9038       c = TREE_REAL_CST (arg);
9039       temp = REAL_VALUE_NEGATIVE (c) ? integer_one_node : integer_zero_node;
9040       return fold_convert_loc (loc, type, temp);
9041     }
9042
9043   /* If ARG is non-negative, the result is always zero.  */
9044   if (tree_expr_nonnegative_p (arg))
9045     return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9046
9047   /* If ARG's format doesn't have signed zeros, return "arg < 0.0".  */
9048   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9049     return fold_build2_loc (loc, LT_EXPR, type, arg,
9050                         build_real (TREE_TYPE (arg), dconst0));
9051
9052   return NULL_TREE;
9053 }
9054
9055 /* Fold function call to builtin copysign, copysignf or copysignl with
9056    arguments ARG1 and ARG2.  Return NULL_TREE if no simplification can
9057    be made.  */
9058
9059 static tree
9060 fold_builtin_copysign (location_t loc, tree fndecl,
9061                        tree arg1, tree arg2, tree type)
9062 {
9063   tree tem;
9064
9065   if (!validate_arg (arg1, REAL_TYPE)
9066       || !validate_arg (arg2, REAL_TYPE))
9067     return NULL_TREE;
9068
9069   /* copysign(X,X) is X.  */
9070   if (operand_equal_p (arg1, arg2, 0))
9071     return fold_convert_loc (loc, type, arg1);
9072
9073   /* If ARG1 and ARG2 are compile-time constants, determine the result.  */
9074   if (TREE_CODE (arg1) == REAL_CST
9075       && TREE_CODE (arg2) == REAL_CST
9076       && !TREE_OVERFLOW (arg1)
9077       && !TREE_OVERFLOW (arg2))
9078     {
9079       REAL_VALUE_TYPE c1, c2;
9080
9081       c1 = TREE_REAL_CST (arg1);
9082       c2 = TREE_REAL_CST (arg2);
9083       /* c1.sign := c2.sign.  */
9084       real_copysign (&c1, &c2);
9085       return build_real (type, c1);
9086     }
9087
9088   /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9089      Remember to evaluate Y for side-effects.  */
9090   if (tree_expr_nonnegative_p (arg2))
9091     return omit_one_operand_loc (loc, type,
9092                              fold_build1_loc (loc, ABS_EXPR, type, arg1),
9093                              arg2);
9094
9095   /* Strip sign changing operations for the first argument.  */
9096   tem = fold_strip_sign_ops (arg1);
9097   if (tem)
9098     return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9099
9100   return NULL_TREE;
9101 }
9102
9103 /* Fold a call to builtin isascii with argument ARG.  */
9104
9105 static tree
9106 fold_builtin_isascii (location_t loc, tree arg)
9107 {
9108   if (!validate_arg (arg, INTEGER_TYPE))
9109     return NULL_TREE;
9110   else
9111     {
9112       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
9113       arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9114                          build_int_cst (NULL_TREE,
9115                                         ~ (unsigned HOST_WIDE_INT) 0x7f));
9116       return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9117                           arg, integer_zero_node);
9118     }
9119 }
9120
9121 /* Fold a call to builtin toascii with argument ARG.  */
9122
9123 static tree
9124 fold_builtin_toascii (location_t loc, tree arg)
9125 {
9126   if (!validate_arg (arg, INTEGER_TYPE))
9127     return NULL_TREE;
9128
9129   /* Transform toascii(c) -> (c & 0x7f).  */
9130   return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9131                       build_int_cst (NULL_TREE, 0x7f));
9132 }
9133
9134 /* Fold a call to builtin isdigit with argument ARG.  */
9135
9136 static tree
9137 fold_builtin_isdigit (location_t loc, tree arg)
9138 {
9139   if (!validate_arg (arg, INTEGER_TYPE))
9140     return NULL_TREE;
9141   else
9142     {
9143       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
9144       /* According to the C standard, isdigit is unaffected by locale.
9145          However, it definitely is affected by the target character set.  */
9146       unsigned HOST_WIDE_INT target_digit0
9147         = lang_hooks.to_target_charset ('0');
9148
9149       if (target_digit0 == 0)
9150         return NULL_TREE;
9151
9152       arg = fold_convert_loc (loc, unsigned_type_node, arg);
9153       arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9154                          build_int_cst (unsigned_type_node, target_digit0));
9155       return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9156                           build_int_cst (unsigned_type_node, 9));
9157     }
9158 }
9159
9160 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
9161
9162 static tree
9163 fold_builtin_fabs (location_t loc, tree arg, tree type)
9164 {
9165   if (!validate_arg (arg, REAL_TYPE))
9166     return NULL_TREE;
9167
9168   arg = fold_convert_loc (loc, type, arg);
9169   if (TREE_CODE (arg) == REAL_CST)
9170     return fold_abs_const (arg, type);
9171   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9172 }
9173
9174 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
9175
9176 static tree
9177 fold_builtin_abs (location_t loc, tree arg, tree type)
9178 {
9179   if (!validate_arg (arg, INTEGER_TYPE))
9180     return NULL_TREE;
9181
9182   arg = fold_convert_loc (loc, type, arg);
9183   if (TREE_CODE (arg) == INTEGER_CST)
9184     return fold_abs_const (arg, type);
9185   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9186 }
9187
9188 /* Fold a call to builtin fmin or fmax.  */
9189
9190 static tree
9191 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9192                         tree type, bool max)
9193 {
9194   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9195     {
9196       /* Calculate the result when the argument is a constant.  */
9197       tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9198
9199       if (res)
9200         return res;
9201
9202       /* If either argument is NaN, return the other one.  Avoid the
9203          transformation if we get (and honor) a signalling NaN.  Using
9204          omit_one_operand() ensures we create a non-lvalue.  */
9205       if (TREE_CODE (arg0) == REAL_CST
9206           && real_isnan (&TREE_REAL_CST (arg0))
9207           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9208               || ! TREE_REAL_CST (arg0).signalling))
9209         return omit_one_operand_loc (loc, type, arg1, arg0);
9210       if (TREE_CODE (arg1) == REAL_CST
9211           && real_isnan (&TREE_REAL_CST (arg1))
9212           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9213               || ! TREE_REAL_CST (arg1).signalling))
9214         return omit_one_operand_loc (loc, type, arg0, arg1);
9215
9216       /* Transform fmin/fmax(x,x) -> x.  */
9217       if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9218         return omit_one_operand_loc (loc, type, arg0, arg1);
9219
9220       /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR.  C99 requires these
9221          functions to return the numeric arg if the other one is NaN.
9222          These tree codes don't honor that, so only transform if
9223          -ffinite-math-only is set.  C99 doesn't require -0.0 to be
9224          handled, so we don't have to worry about it either.  */
9225       if (flag_finite_math_only)
9226         return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9227                             fold_convert_loc (loc, type, arg0),
9228                             fold_convert_loc (loc, type, arg1));
9229     }
9230   return NULL_TREE;
9231 }
9232
9233 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
9234
9235 static tree
9236 fold_builtin_carg (location_t loc, tree arg, tree type)
9237 {
9238   if (validate_arg (arg, COMPLEX_TYPE)
9239       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9240     {
9241       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9242
9243       if (atan2_fn)
9244         {
9245           tree new_arg = builtin_save_expr (arg);
9246           tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9247           tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9248           return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9249         }
9250     }
9251
9252   return NULL_TREE;
9253 }
9254
9255 /* Fold a call to builtin logb/ilogb.  */
9256
9257 static tree
9258 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9259 {
9260   if (! validate_arg (arg, REAL_TYPE))
9261     return NULL_TREE;
9262
9263   STRIP_NOPS (arg);
9264
9265   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9266     {
9267       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9268
9269       switch (value->cl)
9270       {
9271       case rvc_nan:
9272       case rvc_inf:
9273         /* If arg is Inf or NaN and we're logb, return it.  */
9274         if (TREE_CODE (rettype) == REAL_TYPE)
9275           return fold_convert_loc (loc, rettype, arg);
9276         /* Fall through... */
9277       case rvc_zero:
9278         /* Zero may set errno and/or raise an exception for logb, also
9279            for ilogb we don't know FP_ILOGB0.  */
9280         return NULL_TREE;
9281       case rvc_normal:
9282         /* For normal numbers, proceed iff radix == 2.  In GCC,
9283            normalized significands are in the range [0.5, 1.0).  We
9284            want the exponent as if they were [1.0, 2.0) so get the
9285            exponent and subtract 1.  */
9286         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9287           return fold_convert_loc (loc, rettype,
9288                                    build_int_cst (NULL_TREE,
9289                                                   REAL_EXP (value)-1));
9290         break;
9291       }
9292     }
9293
9294   return NULL_TREE;
9295 }
9296
9297 /* Fold a call to builtin significand, if radix == 2.  */
9298
9299 static tree
9300 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9301 {
9302   if (! validate_arg (arg, REAL_TYPE))
9303     return NULL_TREE;
9304
9305   STRIP_NOPS (arg);
9306
9307   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9308     {
9309       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9310
9311       switch (value->cl)
9312       {
9313       case rvc_zero:
9314       case rvc_nan:
9315       case rvc_inf:
9316         /* If arg is +-0, +-Inf or +-NaN, then return it.  */
9317         return fold_convert_loc (loc, rettype, arg);
9318       case rvc_normal:
9319         /* For normal numbers, proceed iff radix == 2.  */
9320         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9321           {
9322             REAL_VALUE_TYPE result = *value;
9323             /* In GCC, normalized significands are in the range [0.5,
9324                1.0).  We want them to be [1.0, 2.0) so set the
9325                exponent to 1.  */
9326             SET_REAL_EXP (&result, 1);
9327             return build_real (rettype, result);
9328           }
9329         break;
9330       }
9331     }
9332
9333   return NULL_TREE;
9334 }
9335
9336 /* Fold a call to builtin frexp, we can assume the base is 2.  */
9337
9338 static tree
9339 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9340 {
9341   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9342     return NULL_TREE;
9343
9344   STRIP_NOPS (arg0);
9345
9346   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9347     return NULL_TREE;
9348
9349   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9350
9351   /* Proceed if a valid pointer type was passed in.  */
9352   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9353     {
9354       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9355       tree frac, exp;
9356
9357       switch (value->cl)
9358       {
9359       case rvc_zero:
9360         /* For +-0, return (*exp = 0, +-0).  */
9361         exp = integer_zero_node;
9362         frac = arg0;
9363         break;
9364       case rvc_nan:
9365       case rvc_inf:
9366         /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
9367         return omit_one_operand_loc (loc, rettype, arg0, arg1);
9368       case rvc_normal:
9369         {
9370           /* Since the frexp function always expects base 2, and in
9371              GCC normalized significands are already in the range
9372              [0.5, 1.0), we have exactly what frexp wants.  */
9373           REAL_VALUE_TYPE frac_rvt = *value;
9374           SET_REAL_EXP (&frac_rvt, 0);
9375           frac = build_real (rettype, frac_rvt);
9376           exp = build_int_cst (NULL_TREE, REAL_EXP (value));
9377         }
9378         break;
9379       default:
9380         gcc_unreachable ();
9381       }
9382
9383       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9384       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9385       TREE_SIDE_EFFECTS (arg1) = 1;
9386       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9387     }
9388
9389   return NULL_TREE;
9390 }
9391
9392 /* Fold a call to builtin ldexp or scalbn/scalbln.  If LDEXP is true
9393    then we can assume the base is two.  If it's false, then we have to
9394    check the mode of the TYPE parameter in certain cases.  */
9395
9396 static tree
9397 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9398                             tree type, bool ldexp)
9399 {
9400   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9401     {
9402       STRIP_NOPS (arg0);
9403       STRIP_NOPS (arg1);
9404
9405       /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0.  */
9406       if (real_zerop (arg0) || integer_zerop (arg1)
9407           || (TREE_CODE (arg0) == REAL_CST
9408               && !real_isfinite (&TREE_REAL_CST (arg0))))
9409         return omit_one_operand_loc (loc, type, arg0, arg1);
9410
9411       /* If both arguments are constant, then try to evaluate it.  */
9412       if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9413           && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9414           && host_integerp (arg1, 0))
9415         {
9416           /* Bound the maximum adjustment to twice the range of the
9417              mode's valid exponents.  Use abs to ensure the range is
9418              positive as a sanity check.  */
9419           const long max_exp_adj = 2 *
9420             labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9421                  - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9422
9423           /* Get the user-requested adjustment.  */
9424           const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9425
9426           /* The requested adjustment must be inside this range.  This
9427              is a preliminary cap to avoid things like overflow, we
9428              may still fail to compute the result for other reasons.  */
9429           if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9430             {
9431               REAL_VALUE_TYPE initial_result;
9432
9433               real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9434
9435               /* Ensure we didn't overflow.  */
9436               if (! real_isinf (&initial_result))
9437                 {
9438                   const REAL_VALUE_TYPE trunc_result
9439                     = real_value_truncate (TYPE_MODE (type), initial_result);
9440
9441                   /* Only proceed if the target mode can hold the
9442                      resulting value.  */
9443                   if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9444                     return build_real (type, trunc_result);
9445                 }
9446             }
9447         }
9448     }
9449
9450   return NULL_TREE;
9451 }
9452
9453 /* Fold a call to builtin modf.  */
9454
9455 static tree
9456 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9457 {
9458   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9459     return NULL_TREE;
9460
9461   STRIP_NOPS (arg0);
9462
9463   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9464     return NULL_TREE;
9465
9466   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9467
9468   /* Proceed if a valid pointer type was passed in.  */
9469   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9470     {
9471       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9472       REAL_VALUE_TYPE trunc, frac;
9473
9474       switch (value->cl)
9475       {
9476       case rvc_nan:
9477       case rvc_zero:
9478         /* For +-NaN or +-0, return (*arg1 = arg0, arg0).  */
9479         trunc = frac = *value;
9480         break;
9481       case rvc_inf:
9482         /* For +-Inf, return (*arg1 = arg0, +-0).  */
9483         frac = dconst0;
9484         frac.sign = value->sign;
9485         trunc = *value;
9486         break;
9487       case rvc_normal:
9488         /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)).  */
9489         real_trunc (&trunc, VOIDmode, value);
9490         real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9491         /* If the original number was negative and already
9492            integral, then the fractional part is -0.0.  */
9493         if (value->sign && frac.cl == rvc_zero)
9494           frac.sign = value->sign;
9495         break;
9496       }
9497
9498       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9499       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9500                           build_real (rettype, trunc));
9501       TREE_SIDE_EFFECTS (arg1) = 1;
9502       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9503                           build_real (rettype, frac));
9504     }
9505
9506   return NULL_TREE;
9507 }
9508
9509 /* Given a location LOC, an interclass builtin function decl FNDECL
9510    and its single argument ARG, return an folded expression computing
9511    the same, or NULL_TREE if we either couldn't or didn't want to fold
9512    (the latter happen if there's an RTL instruction available).  */
9513
9514 static tree
9515 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9516 {
9517   enum machine_mode mode;
9518
9519   if (!validate_arg (arg, REAL_TYPE))
9520     return NULL_TREE;
9521
9522   if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9523     return NULL_TREE;
9524
9525   mode = TYPE_MODE (TREE_TYPE (arg));
9526
9527   /* If there is no optab, try generic code.  */
9528   switch (DECL_FUNCTION_CODE (fndecl))
9529     {
9530       tree result;
9531
9532     CASE_FLT_FN (BUILT_IN_ISINF):
9533       {
9534         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
9535         tree const isgr_fn = built_in_decls[BUILT_IN_ISGREATER];
9536         tree const type = TREE_TYPE (arg);
9537         REAL_VALUE_TYPE r;
9538         char buf[128];
9539
9540         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9541         real_from_string (&r, buf);
9542         result = build_call_expr (isgr_fn, 2,
9543                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9544                                   build_real (type, r));
9545         return result;
9546       }
9547     CASE_FLT_FN (BUILT_IN_FINITE):
9548     case BUILT_IN_ISFINITE:
9549       {
9550         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
9551         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9552         tree const type = TREE_TYPE (arg);
9553         REAL_VALUE_TYPE r;
9554         char buf[128];
9555
9556         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9557         real_from_string (&r, buf);
9558         result = build_call_expr (isle_fn, 2,
9559                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9560                                   build_real (type, r));
9561         /*result = fold_build2_loc (loc, UNGT_EXPR,
9562                                   TREE_TYPE (TREE_TYPE (fndecl)),
9563                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9564                                   build_real (type, r));
9565         result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9566                                   TREE_TYPE (TREE_TYPE (fndecl)),
9567                                   result);*/
9568         return result;
9569       }
9570     case BUILT_IN_ISNORMAL:
9571       {
9572         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9573            islessequal(fabs(x),DBL_MAX).  */
9574         tree const isle_fn = built_in_decls[BUILT_IN_ISLESSEQUAL];
9575         tree const isge_fn = built_in_decls[BUILT_IN_ISGREATEREQUAL];
9576         tree const type = TREE_TYPE (arg);
9577         REAL_VALUE_TYPE rmax, rmin;
9578         char buf[128];
9579
9580         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9581         real_from_string (&rmax, buf);
9582         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9583         real_from_string (&rmin, buf);
9584         arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9585         result = build_call_expr (isle_fn, 2, arg,
9586                                   build_real (type, rmax));
9587         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
9588                               build_call_expr (isge_fn, 2, arg,
9589                                                build_real (type, rmin)));
9590         return result;
9591       }
9592     default:
9593       break;
9594     }
9595
9596   return NULL_TREE;
9597 }
9598
9599 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9600    ARG is the argument for the call.  */
9601
9602 static tree
9603 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
9604 {
9605   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9606   REAL_VALUE_TYPE r;
9607
9608   if (!validate_arg (arg, REAL_TYPE))
9609     return NULL_TREE;
9610
9611   switch (builtin_index)
9612     {
9613     case BUILT_IN_ISINF:
9614       if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9615         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9616
9617       if (TREE_CODE (arg) == REAL_CST)
9618         {
9619           r = TREE_REAL_CST (arg);
9620           if (real_isinf (&r))
9621             return real_compare (GT_EXPR, &r, &dconst0)
9622                    ? integer_one_node : integer_minus_one_node;
9623           else
9624             return integer_zero_node;
9625         }
9626
9627       return NULL_TREE;
9628
9629     case BUILT_IN_ISINF_SIGN:
9630       {
9631         /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
9632         /* In a boolean context, GCC will fold the inner COND_EXPR to
9633            1.  So e.g. "if (isinf_sign(x))" would be folded to just
9634            "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
9635         tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
9636         tree isinf_fn = built_in_decls[BUILT_IN_ISINF];
9637         tree tmp = NULL_TREE;
9638
9639         arg = builtin_save_expr (arg);
9640
9641         if (signbit_fn && isinf_fn)
9642           {
9643             tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
9644             tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
9645
9646             signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9647                                         signbit_call, integer_zero_node);
9648             isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
9649                                       isinf_call, integer_zero_node);
9650
9651             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
9652                                integer_minus_one_node, integer_one_node);
9653             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9654                                isinf_call, tmp,
9655                                integer_zero_node);
9656           }
9657
9658         return tmp;
9659       }
9660
9661     case BUILT_IN_ISFINITE:
9662       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
9663           && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9664         return omit_one_operand_loc (loc, type, integer_one_node, arg);
9665
9666       if (TREE_CODE (arg) == REAL_CST)
9667         {
9668           r = TREE_REAL_CST (arg);
9669           return real_isfinite (&r) ? integer_one_node : integer_zero_node;
9670         }
9671
9672       return NULL_TREE;
9673
9674     case BUILT_IN_ISNAN:
9675       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
9676         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9677
9678       if (TREE_CODE (arg) == REAL_CST)
9679         {
9680           r = TREE_REAL_CST (arg);
9681           return real_isnan (&r) ? integer_one_node : integer_zero_node;
9682         }
9683
9684       arg = builtin_save_expr (arg);
9685       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
9686
9687     default:
9688       gcc_unreachable ();
9689     }
9690 }
9691
9692 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
9693    This builtin will generate code to return the appropriate floating
9694    point classification depending on the value of the floating point
9695    number passed in.  The possible return values must be supplied as
9696    int arguments to the call in the following order: FP_NAN, FP_INFINITE,
9697    FP_NORMAL, FP_SUBNORMAL and FP_ZERO.  The ellipses is for exactly
9698    one floating point argument which is "type generic".  */
9699
9700 static tree
9701 fold_builtin_fpclassify (location_t loc, tree exp)
9702 {
9703   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
9704     arg, type, res, tmp;
9705   enum machine_mode mode;
9706   REAL_VALUE_TYPE r;
9707   char buf[128];
9708
9709   /* Verify the required arguments in the original call.  */
9710   if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
9711                          INTEGER_TYPE, INTEGER_TYPE,
9712                          INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
9713     return NULL_TREE;
9714
9715   fp_nan = CALL_EXPR_ARG (exp, 0);
9716   fp_infinite = CALL_EXPR_ARG (exp, 1);
9717   fp_normal = CALL_EXPR_ARG (exp, 2);
9718   fp_subnormal = CALL_EXPR_ARG (exp, 3);
9719   fp_zero = CALL_EXPR_ARG (exp, 4);
9720   arg = CALL_EXPR_ARG (exp, 5);
9721   type = TREE_TYPE (arg);
9722   mode = TYPE_MODE (type);
9723   arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9724
9725   /* fpclassify(x) ->
9726        isnan(x) ? FP_NAN :
9727          (fabs(x) == Inf ? FP_INFINITE :
9728            (fabs(x) >= DBL_MIN ? FP_NORMAL :
9729              (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
9730
9731   tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9732                      build_real (type, dconst0));
9733   res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
9734                      tmp, fp_zero, fp_subnormal);
9735
9736   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9737   real_from_string (&r, buf);
9738   tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
9739                      arg, build_real (type, r));
9740   res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
9741
9742   if (HONOR_INFINITIES (mode))
9743     {
9744       real_inf (&r);
9745       tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
9746                          build_real (type, r));
9747       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
9748                          fp_infinite, res);
9749     }
9750
9751   if (HONOR_NANS (mode))
9752     {
9753       tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
9754       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
9755     }
9756
9757   return res;
9758 }
9759
9760 /* Fold a call to an unordered comparison function such as
9761    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
9762    being called and ARG0 and ARG1 are the arguments for the call.
9763    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
9764    the opposite of the desired result.  UNORDERED_CODE is used
9765    for modes that can hold NaNs and ORDERED_CODE is used for
9766    the rest.  */
9767
9768 static tree
9769 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
9770                             enum tree_code unordered_code,
9771                             enum tree_code ordered_code)
9772 {
9773   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9774   enum tree_code code;
9775   tree type0, type1;
9776   enum tree_code code0, code1;
9777   tree cmp_type = NULL_TREE;
9778
9779   type0 = TREE_TYPE (arg0);
9780   type1 = TREE_TYPE (arg1);
9781
9782   code0 = TREE_CODE (type0);
9783   code1 = TREE_CODE (type1);
9784
9785   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
9786     /* Choose the wider of two real types.  */
9787     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
9788       ? type0 : type1;
9789   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
9790     cmp_type = type0;
9791   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
9792     cmp_type = type1;
9793
9794   arg0 = fold_convert_loc (loc, cmp_type, arg0);
9795   arg1 = fold_convert_loc (loc, cmp_type, arg1);
9796
9797   if (unordered_code == UNORDERED_EXPR)
9798     {
9799       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9800         return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
9801       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
9802     }
9803
9804   code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
9805                                                    : ordered_code;
9806   return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
9807                       fold_build2_loc (loc, code, type, arg0, arg1));
9808 }
9809
9810 /* Fold a call to built-in function FNDECL with 0 arguments.
9811    IGNORE is true if the result of the function call is ignored.  This
9812    function returns NULL_TREE if no simplification was possible.  */
9813
9814 static tree
9815 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
9816 {
9817   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9818   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9819   switch (fcode)
9820     {
9821     CASE_FLT_FN (BUILT_IN_INF):
9822     case BUILT_IN_INFD32:
9823     case BUILT_IN_INFD64:
9824     case BUILT_IN_INFD128:
9825       return fold_builtin_inf (loc, type, true);
9826
9827     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
9828       return fold_builtin_inf (loc, type, false);
9829
9830     case BUILT_IN_CLASSIFY_TYPE:
9831       return fold_builtin_classify_type (NULL_TREE);
9832
9833     default:
9834       break;
9835     }
9836   return NULL_TREE;
9837 }
9838
9839 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
9840    IGNORE is true if the result of the function call is ignored.  This
9841    function returns NULL_TREE if no simplification was possible.  */
9842
9843 static tree
9844 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
9845 {
9846   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9847   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9848   switch (fcode)
9849     {
9850     case BUILT_IN_CONSTANT_P:
9851       {
9852         tree val = fold_builtin_constant_p (arg0);
9853
9854         /* Gimplification will pull the CALL_EXPR for the builtin out of
9855            an if condition.  When not optimizing, we'll not CSE it back.
9856            To avoid link error types of regressions, return false now.  */
9857         if (!val && !optimize)
9858           val = integer_zero_node;
9859
9860         return val;
9861       }
9862
9863     case BUILT_IN_CLASSIFY_TYPE:
9864       return fold_builtin_classify_type (arg0);
9865
9866     case BUILT_IN_STRLEN:
9867       return fold_builtin_strlen (loc, type, arg0);
9868
9869     CASE_FLT_FN (BUILT_IN_FABS):
9870       return fold_builtin_fabs (loc, arg0, type);
9871
9872     case BUILT_IN_ABS:
9873     case BUILT_IN_LABS:
9874     case BUILT_IN_LLABS:
9875     case BUILT_IN_IMAXABS:
9876       return fold_builtin_abs (loc, arg0, type);
9877
9878     CASE_FLT_FN (BUILT_IN_CONJ):
9879       if (validate_arg (arg0, COMPLEX_TYPE)
9880         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9881         return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
9882     break;
9883
9884     CASE_FLT_FN (BUILT_IN_CREAL):
9885       if (validate_arg (arg0, COMPLEX_TYPE)
9886         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9887         return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
9888     break;
9889
9890     CASE_FLT_FN (BUILT_IN_CIMAG):
9891       if (validate_arg (arg0, COMPLEX_TYPE)
9892           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9893         return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
9894     break;
9895
9896     CASE_FLT_FN (BUILT_IN_CCOS):
9897       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
9898
9899     CASE_FLT_FN (BUILT_IN_CCOSH):
9900       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
9901
9902     CASE_FLT_FN (BUILT_IN_CPROJ):
9903       return fold_builtin_cproj(loc, arg0, type);
9904
9905     CASE_FLT_FN (BUILT_IN_CSIN):
9906       if (validate_arg (arg0, COMPLEX_TYPE)
9907           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9908         return do_mpc_arg1 (arg0, type, mpc_sin);
9909     break;
9910
9911     CASE_FLT_FN (BUILT_IN_CSINH):
9912       if (validate_arg (arg0, COMPLEX_TYPE)
9913           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9914         return do_mpc_arg1 (arg0, type, mpc_sinh);
9915     break;
9916
9917     CASE_FLT_FN (BUILT_IN_CTAN):
9918       if (validate_arg (arg0, COMPLEX_TYPE)
9919           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9920         return do_mpc_arg1 (arg0, type, mpc_tan);
9921     break;
9922
9923     CASE_FLT_FN (BUILT_IN_CTANH):
9924       if (validate_arg (arg0, COMPLEX_TYPE)
9925           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9926         return do_mpc_arg1 (arg0, type, mpc_tanh);
9927     break;
9928
9929     CASE_FLT_FN (BUILT_IN_CLOG):
9930       if (validate_arg (arg0, COMPLEX_TYPE)
9931           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9932         return do_mpc_arg1 (arg0, type, mpc_log);
9933     break;
9934
9935     CASE_FLT_FN (BUILT_IN_CSQRT):
9936       if (validate_arg (arg0, COMPLEX_TYPE)
9937           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9938         return do_mpc_arg1 (arg0, type, mpc_sqrt);
9939     break;
9940
9941     CASE_FLT_FN (BUILT_IN_CASIN):
9942       if (validate_arg (arg0, COMPLEX_TYPE)
9943           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9944         return do_mpc_arg1 (arg0, type, mpc_asin);
9945     break;
9946
9947     CASE_FLT_FN (BUILT_IN_CACOS):
9948       if (validate_arg (arg0, COMPLEX_TYPE)
9949           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9950         return do_mpc_arg1 (arg0, type, mpc_acos);
9951     break;
9952
9953     CASE_FLT_FN (BUILT_IN_CATAN):
9954       if (validate_arg (arg0, COMPLEX_TYPE)
9955           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9956         return do_mpc_arg1 (arg0, type, mpc_atan);
9957     break;
9958
9959     CASE_FLT_FN (BUILT_IN_CASINH):
9960       if (validate_arg (arg0, COMPLEX_TYPE)
9961           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9962         return do_mpc_arg1 (arg0, type, mpc_asinh);
9963     break;
9964
9965     CASE_FLT_FN (BUILT_IN_CACOSH):
9966       if (validate_arg (arg0, COMPLEX_TYPE)
9967           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9968         return do_mpc_arg1 (arg0, type, mpc_acosh);
9969     break;
9970
9971     CASE_FLT_FN (BUILT_IN_CATANH):
9972       if (validate_arg (arg0, COMPLEX_TYPE)
9973           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
9974         return do_mpc_arg1 (arg0, type, mpc_atanh);
9975     break;
9976
9977     CASE_FLT_FN (BUILT_IN_CABS):
9978       return fold_builtin_cabs (loc, arg0, type, fndecl);
9979
9980     CASE_FLT_FN (BUILT_IN_CARG):
9981       return fold_builtin_carg (loc, arg0, type);
9982
9983     CASE_FLT_FN (BUILT_IN_SQRT):
9984       return fold_builtin_sqrt (loc, arg0, type);
9985
9986     CASE_FLT_FN (BUILT_IN_CBRT):
9987       return fold_builtin_cbrt (loc, arg0, type);
9988
9989     CASE_FLT_FN (BUILT_IN_ASIN):
9990       if (validate_arg (arg0, REAL_TYPE))
9991         return do_mpfr_arg1 (arg0, type, mpfr_asin,
9992                              &dconstm1, &dconst1, true);
9993     break;
9994
9995     CASE_FLT_FN (BUILT_IN_ACOS):
9996       if (validate_arg (arg0, REAL_TYPE))
9997         return do_mpfr_arg1 (arg0, type, mpfr_acos,
9998                              &dconstm1, &dconst1, true);
9999     break;
10000
10001     CASE_FLT_FN (BUILT_IN_ATAN):
10002       if (validate_arg (arg0, REAL_TYPE))
10003         return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10004     break;
10005
10006     CASE_FLT_FN (BUILT_IN_ASINH):
10007       if (validate_arg (arg0, REAL_TYPE))
10008         return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10009     break;
10010
10011     CASE_FLT_FN (BUILT_IN_ACOSH):
10012       if (validate_arg (arg0, REAL_TYPE))
10013         return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10014                              &dconst1, NULL, true);
10015     break;
10016
10017     CASE_FLT_FN (BUILT_IN_ATANH):
10018       if (validate_arg (arg0, REAL_TYPE))
10019         return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10020                              &dconstm1, &dconst1, false);
10021     break;
10022
10023     CASE_FLT_FN (BUILT_IN_SIN):
10024       if (validate_arg (arg0, REAL_TYPE))
10025         return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10026     break;
10027
10028     CASE_FLT_FN (BUILT_IN_COS):
10029       return fold_builtin_cos (loc, arg0, type, fndecl);
10030
10031     CASE_FLT_FN (BUILT_IN_TAN):
10032       return fold_builtin_tan (arg0, type);
10033
10034     CASE_FLT_FN (BUILT_IN_CEXP):
10035       return fold_builtin_cexp (loc, arg0, type);
10036
10037     CASE_FLT_FN (BUILT_IN_CEXPI):
10038       if (validate_arg (arg0, REAL_TYPE))
10039         return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10040     break;
10041
10042     CASE_FLT_FN (BUILT_IN_SINH):
10043       if (validate_arg (arg0, REAL_TYPE))
10044         return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10045     break;
10046
10047     CASE_FLT_FN (BUILT_IN_COSH):
10048       return fold_builtin_cosh (loc, arg0, type, fndecl);
10049
10050     CASE_FLT_FN (BUILT_IN_TANH):
10051       if (validate_arg (arg0, REAL_TYPE))
10052         return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10053     break;
10054
10055     CASE_FLT_FN (BUILT_IN_ERF):
10056       if (validate_arg (arg0, REAL_TYPE))
10057         return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10058     break;
10059
10060     CASE_FLT_FN (BUILT_IN_ERFC):
10061       if (validate_arg (arg0, REAL_TYPE))
10062         return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10063     break;
10064
10065     CASE_FLT_FN (BUILT_IN_TGAMMA):
10066       if (validate_arg (arg0, REAL_TYPE))
10067         return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10068     break;
10069
10070     CASE_FLT_FN (BUILT_IN_EXP):
10071       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10072
10073     CASE_FLT_FN (BUILT_IN_EXP2):
10074       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10075
10076     CASE_FLT_FN (BUILT_IN_EXP10):
10077     CASE_FLT_FN (BUILT_IN_POW10):
10078       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10079
10080     CASE_FLT_FN (BUILT_IN_EXPM1):
10081       if (validate_arg (arg0, REAL_TYPE))
10082         return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10083     break;
10084
10085     CASE_FLT_FN (BUILT_IN_LOG):
10086     return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10087
10088     CASE_FLT_FN (BUILT_IN_LOG2):
10089       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10090
10091     CASE_FLT_FN (BUILT_IN_LOG10):
10092       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10093
10094     CASE_FLT_FN (BUILT_IN_LOG1P):
10095       if (validate_arg (arg0, REAL_TYPE))
10096         return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10097                              &dconstm1, NULL, false);
10098     break;
10099
10100     CASE_FLT_FN (BUILT_IN_J0):
10101       if (validate_arg (arg0, REAL_TYPE))
10102         return do_mpfr_arg1 (arg0, type, mpfr_j0,
10103                              NULL, NULL, 0);
10104     break;
10105
10106     CASE_FLT_FN (BUILT_IN_J1):
10107       if (validate_arg (arg0, REAL_TYPE))
10108         return do_mpfr_arg1 (arg0, type, mpfr_j1,
10109                              NULL, NULL, 0);
10110     break;
10111
10112     CASE_FLT_FN (BUILT_IN_Y0):
10113       if (validate_arg (arg0, REAL_TYPE))
10114         return do_mpfr_arg1 (arg0, type, mpfr_y0,
10115                              &dconst0, NULL, false);
10116     break;
10117
10118     CASE_FLT_FN (BUILT_IN_Y1):
10119       if (validate_arg (arg0, REAL_TYPE))
10120         return do_mpfr_arg1 (arg0, type, mpfr_y1,
10121                              &dconst0, NULL, false);
10122     break;
10123
10124     CASE_FLT_FN (BUILT_IN_NAN):
10125     case BUILT_IN_NAND32:
10126     case BUILT_IN_NAND64:
10127     case BUILT_IN_NAND128:
10128       return fold_builtin_nan (arg0, type, true);
10129
10130     CASE_FLT_FN (BUILT_IN_NANS):
10131       return fold_builtin_nan (arg0, type, false);
10132
10133     CASE_FLT_FN (BUILT_IN_FLOOR):
10134       return fold_builtin_floor (loc, fndecl, arg0);
10135
10136     CASE_FLT_FN (BUILT_IN_CEIL):
10137       return fold_builtin_ceil (loc, fndecl, arg0);
10138
10139     CASE_FLT_FN (BUILT_IN_TRUNC):
10140       return fold_builtin_trunc (loc, fndecl, arg0);
10141
10142     CASE_FLT_FN (BUILT_IN_ROUND):
10143       return fold_builtin_round (loc, fndecl, arg0);
10144
10145     CASE_FLT_FN (BUILT_IN_NEARBYINT):
10146     CASE_FLT_FN (BUILT_IN_RINT):
10147       return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10148
10149     CASE_FLT_FN (BUILT_IN_LCEIL):
10150     CASE_FLT_FN (BUILT_IN_LLCEIL):
10151     CASE_FLT_FN (BUILT_IN_LFLOOR):
10152     CASE_FLT_FN (BUILT_IN_LLFLOOR):
10153     CASE_FLT_FN (BUILT_IN_LROUND):
10154     CASE_FLT_FN (BUILT_IN_LLROUND):
10155       return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10156
10157     CASE_FLT_FN (BUILT_IN_LRINT):
10158     CASE_FLT_FN (BUILT_IN_LLRINT):
10159       return fold_fixed_mathfn (loc, fndecl, arg0);
10160
10161     case BUILT_IN_BSWAP32:
10162     case BUILT_IN_BSWAP64:
10163       return fold_builtin_bswap (fndecl, arg0);
10164
10165     CASE_INT_FN (BUILT_IN_FFS):
10166     CASE_INT_FN (BUILT_IN_CLZ):
10167     CASE_INT_FN (BUILT_IN_CTZ):
10168     CASE_INT_FN (BUILT_IN_POPCOUNT):
10169     CASE_INT_FN (BUILT_IN_PARITY):
10170       return fold_builtin_bitop (fndecl, arg0);
10171
10172     CASE_FLT_FN (BUILT_IN_SIGNBIT):
10173       return fold_builtin_signbit (loc, arg0, type);
10174
10175     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10176       return fold_builtin_significand (loc, arg0, type);
10177
10178     CASE_FLT_FN (BUILT_IN_ILOGB):
10179     CASE_FLT_FN (BUILT_IN_LOGB):
10180       return fold_builtin_logb (loc, arg0, type);
10181
10182     case BUILT_IN_ISASCII:
10183       return fold_builtin_isascii (loc, arg0);
10184
10185     case BUILT_IN_TOASCII:
10186       return fold_builtin_toascii (loc, arg0);
10187
10188     case BUILT_IN_ISDIGIT:
10189       return fold_builtin_isdigit (loc, arg0);
10190
10191     CASE_FLT_FN (BUILT_IN_FINITE):
10192     case BUILT_IN_FINITED32:
10193     case BUILT_IN_FINITED64:
10194     case BUILT_IN_FINITED128:
10195     case BUILT_IN_ISFINITE:
10196       {
10197         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10198         if (ret)
10199           return ret;
10200         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10201       }
10202
10203     CASE_FLT_FN (BUILT_IN_ISINF):
10204     case BUILT_IN_ISINFD32:
10205     case BUILT_IN_ISINFD64:
10206     case BUILT_IN_ISINFD128:
10207       {
10208         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10209         if (ret)
10210           return ret;
10211         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10212       }
10213
10214     case BUILT_IN_ISNORMAL:
10215       return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10216
10217     case BUILT_IN_ISINF_SIGN:
10218       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10219
10220     CASE_FLT_FN (BUILT_IN_ISNAN):
10221     case BUILT_IN_ISNAND32:
10222     case BUILT_IN_ISNAND64:
10223     case BUILT_IN_ISNAND128:
10224       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10225
10226     case BUILT_IN_PRINTF:
10227     case BUILT_IN_PRINTF_UNLOCKED:
10228     case BUILT_IN_VPRINTF:
10229       return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10230
10231     case BUILT_IN_FREE:
10232       if (integer_zerop (arg0))
10233         return build_empty_stmt (loc);
10234       break;
10235
10236     default:
10237       break;
10238     }
10239
10240   return NULL_TREE;
10241
10242 }
10243
10244 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10245    IGNORE is true if the result of the function call is ignored.  This
10246    function returns NULL_TREE if no simplification was possible.  */
10247
10248 static tree
10249 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10250 {
10251   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10252   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10253
10254   switch (fcode)
10255     {
10256     CASE_FLT_FN (BUILT_IN_JN):
10257       if (validate_arg (arg0, INTEGER_TYPE)
10258           && validate_arg (arg1, REAL_TYPE))
10259         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10260     break;
10261
10262     CASE_FLT_FN (BUILT_IN_YN):
10263       if (validate_arg (arg0, INTEGER_TYPE)
10264           && validate_arg (arg1, REAL_TYPE))
10265         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10266                                  &dconst0, false);
10267     break;
10268
10269     CASE_FLT_FN (BUILT_IN_DREM):
10270     CASE_FLT_FN (BUILT_IN_REMAINDER):
10271       if (validate_arg (arg0, REAL_TYPE)
10272           && validate_arg(arg1, REAL_TYPE))
10273         return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10274     break;
10275
10276     CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10277     CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10278       if (validate_arg (arg0, REAL_TYPE)
10279           && validate_arg(arg1, POINTER_TYPE))
10280         return do_mpfr_lgamma_r (arg0, arg1, type);
10281     break;
10282
10283     CASE_FLT_FN (BUILT_IN_ATAN2):
10284       if (validate_arg (arg0, REAL_TYPE)
10285           && validate_arg(arg1, REAL_TYPE))
10286         return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10287     break;
10288
10289     CASE_FLT_FN (BUILT_IN_FDIM):
10290       if (validate_arg (arg0, REAL_TYPE)
10291           && validate_arg(arg1, REAL_TYPE))
10292         return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10293     break;
10294
10295     CASE_FLT_FN (BUILT_IN_HYPOT):
10296       return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10297
10298     CASE_FLT_FN (BUILT_IN_CPOW):
10299       if (validate_arg (arg0, COMPLEX_TYPE)
10300           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10301           && validate_arg (arg1, COMPLEX_TYPE)
10302           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10303         return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10304     break;
10305
10306     CASE_FLT_FN (BUILT_IN_LDEXP):
10307       return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10308     CASE_FLT_FN (BUILT_IN_SCALBN):
10309     CASE_FLT_FN (BUILT_IN_SCALBLN):
10310       return fold_builtin_load_exponent (loc, arg0, arg1,
10311                                          type, /*ldexp=*/false);
10312
10313     CASE_FLT_FN (BUILT_IN_FREXP):
10314       return fold_builtin_frexp (loc, arg0, arg1, type);
10315
10316     CASE_FLT_FN (BUILT_IN_MODF):
10317       return fold_builtin_modf (loc, arg0, arg1, type);
10318
10319     case BUILT_IN_BZERO:
10320       return fold_builtin_bzero (loc, arg0, arg1, ignore);
10321
10322     case BUILT_IN_FPUTS:
10323       return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10324
10325     case BUILT_IN_FPUTS_UNLOCKED:
10326       return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10327
10328     case BUILT_IN_STRSTR:
10329       return fold_builtin_strstr (loc, arg0, arg1, type);
10330
10331     case BUILT_IN_STRCAT:
10332       return fold_builtin_strcat (loc, arg0, arg1);
10333
10334     case BUILT_IN_STRSPN:
10335       return fold_builtin_strspn (loc, arg0, arg1);
10336
10337     case BUILT_IN_STRCSPN:
10338       return fold_builtin_strcspn (loc, arg0, arg1);
10339
10340     case BUILT_IN_STRCHR:
10341     case BUILT_IN_INDEX:
10342       return fold_builtin_strchr (loc, arg0, arg1, type);
10343
10344     case BUILT_IN_STRRCHR:
10345     case BUILT_IN_RINDEX:
10346       return fold_builtin_strrchr (loc, arg0, arg1, type);
10347
10348     case BUILT_IN_STRCPY:
10349       return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10350
10351     case BUILT_IN_STPCPY:
10352       if (ignore)
10353         {
10354           tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
10355           if (!fn)
10356             break;
10357
10358           return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10359         }
10360       else
10361         return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10362       break;
10363
10364     case BUILT_IN_STRCMP:
10365       return fold_builtin_strcmp (loc, arg0, arg1);
10366
10367     case BUILT_IN_STRPBRK:
10368       return fold_builtin_strpbrk (loc, arg0, arg1, type);
10369
10370     case BUILT_IN_EXPECT:
10371       return fold_builtin_expect (loc, arg0, arg1);
10372
10373     CASE_FLT_FN (BUILT_IN_POW):
10374       return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10375
10376     CASE_FLT_FN (BUILT_IN_POWI):
10377       return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10378
10379     CASE_FLT_FN (BUILT_IN_COPYSIGN):
10380       return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10381
10382     CASE_FLT_FN (BUILT_IN_FMIN):
10383       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10384
10385     CASE_FLT_FN (BUILT_IN_FMAX):
10386       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10387
10388     case BUILT_IN_ISGREATER:
10389       return fold_builtin_unordered_cmp (loc, fndecl,
10390                                          arg0, arg1, UNLE_EXPR, LE_EXPR);
10391     case BUILT_IN_ISGREATEREQUAL:
10392       return fold_builtin_unordered_cmp (loc, fndecl,
10393                                          arg0, arg1, UNLT_EXPR, LT_EXPR);
10394     case BUILT_IN_ISLESS:
10395       return fold_builtin_unordered_cmp (loc, fndecl,
10396                                          arg0, arg1, UNGE_EXPR, GE_EXPR);
10397     case BUILT_IN_ISLESSEQUAL:
10398       return fold_builtin_unordered_cmp (loc, fndecl,
10399                                          arg0, arg1, UNGT_EXPR, GT_EXPR);
10400     case BUILT_IN_ISLESSGREATER:
10401       return fold_builtin_unordered_cmp (loc, fndecl,
10402                                          arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10403     case BUILT_IN_ISUNORDERED:
10404       return fold_builtin_unordered_cmp (loc, fndecl,
10405                                          arg0, arg1, UNORDERED_EXPR,
10406                                          NOP_EXPR);
10407
10408       /* We do the folding for va_start in the expander.  */
10409     case BUILT_IN_VA_START:
10410       break;
10411
10412     case BUILT_IN_SPRINTF:
10413       return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10414
10415     case BUILT_IN_OBJECT_SIZE:
10416       return fold_builtin_object_size (arg0, arg1);
10417
10418     case BUILT_IN_PRINTF:
10419     case BUILT_IN_PRINTF_UNLOCKED:
10420     case BUILT_IN_VPRINTF:
10421       return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10422
10423     case BUILT_IN_PRINTF_CHK:
10424     case BUILT_IN_VPRINTF_CHK:
10425       if (!validate_arg (arg0, INTEGER_TYPE)
10426           || TREE_SIDE_EFFECTS (arg0))
10427         return NULL_TREE;
10428       else
10429         return fold_builtin_printf (loc, fndecl,
10430                                     arg1, NULL_TREE, ignore, fcode);
10431     break;
10432
10433     case BUILT_IN_FPRINTF:
10434     case BUILT_IN_FPRINTF_UNLOCKED:
10435     case BUILT_IN_VFPRINTF:
10436       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10437                                    ignore, fcode);
10438
10439     default:
10440       break;
10441     }
10442   return NULL_TREE;
10443 }
10444
10445 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10446    and ARG2.  IGNORE is true if the result of the function call is ignored.
10447    This function returns NULL_TREE if no simplification was possible.  */
10448
10449 static tree
10450 fold_builtin_3 (location_t loc, tree fndecl,
10451                 tree arg0, tree arg1, tree arg2, bool ignore)
10452 {
10453   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10454   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10455   switch (fcode)
10456     {
10457
10458     CASE_FLT_FN (BUILT_IN_SINCOS):
10459       return fold_builtin_sincos (loc, arg0, arg1, arg2);
10460
10461     CASE_FLT_FN (BUILT_IN_FMA):
10462       if (validate_arg (arg0, REAL_TYPE)
10463           && validate_arg(arg1, REAL_TYPE)
10464           && validate_arg(arg2, REAL_TYPE))
10465         return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
10466     break;
10467
10468     CASE_FLT_FN (BUILT_IN_REMQUO):
10469       if (validate_arg (arg0, REAL_TYPE)
10470           && validate_arg(arg1, REAL_TYPE)
10471           && validate_arg(arg2, POINTER_TYPE))
10472         return do_mpfr_remquo (arg0, arg1, arg2);
10473     break;
10474
10475     case BUILT_IN_MEMSET:
10476       return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10477
10478     case BUILT_IN_BCOPY:
10479       return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10480                                      void_type_node, true, /*endp=*/3);
10481
10482     case BUILT_IN_MEMCPY:
10483       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10484                                      type, ignore, /*endp=*/0);
10485
10486     case BUILT_IN_MEMPCPY:
10487       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10488                                      type, ignore, /*endp=*/1);
10489
10490     case BUILT_IN_MEMMOVE:
10491       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10492                                      type, ignore, /*endp=*/3);
10493
10494     case BUILT_IN_STRNCAT:
10495       return fold_builtin_strncat (loc, arg0, arg1, arg2);
10496
10497     case BUILT_IN_STRNCPY:
10498       return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10499
10500     case BUILT_IN_STRNCMP:
10501       return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10502
10503     case BUILT_IN_MEMCHR:
10504       return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10505
10506     case BUILT_IN_BCMP:
10507     case BUILT_IN_MEMCMP:
10508       return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10509
10510     case BUILT_IN_SPRINTF:
10511       return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10512
10513     case BUILT_IN_STRCPY_CHK:
10514     case BUILT_IN_STPCPY_CHK:
10515       return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10516                                       ignore, fcode);
10517
10518     case BUILT_IN_STRCAT_CHK:
10519       return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10520
10521     case BUILT_IN_PRINTF_CHK:
10522     case BUILT_IN_VPRINTF_CHK:
10523       if (!validate_arg (arg0, INTEGER_TYPE)
10524           || TREE_SIDE_EFFECTS (arg0))
10525         return NULL_TREE;
10526       else
10527         return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10528     break;
10529
10530     case BUILT_IN_FPRINTF:
10531     case BUILT_IN_FPRINTF_UNLOCKED:
10532     case BUILT_IN_VFPRINTF:
10533       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10534                                    ignore, fcode);
10535
10536     case BUILT_IN_FPRINTF_CHK:
10537     case BUILT_IN_VFPRINTF_CHK:
10538       if (!validate_arg (arg1, INTEGER_TYPE)
10539           || TREE_SIDE_EFFECTS (arg1))
10540         return NULL_TREE;
10541       else
10542         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10543                                      ignore, fcode);
10544
10545     default:
10546       break;
10547     }
10548   return NULL_TREE;
10549 }
10550
10551 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10552    ARG2, and ARG3.  IGNORE is true if the result of the function call is
10553    ignored.  This function returns NULL_TREE if no simplification was
10554    possible.  */
10555
10556 static tree
10557 fold_builtin_4 (location_t loc, tree fndecl,
10558                 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10559 {
10560   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10561
10562   switch (fcode)
10563     {
10564     case BUILT_IN_MEMCPY_CHK:
10565     case BUILT_IN_MEMPCPY_CHK:
10566     case BUILT_IN_MEMMOVE_CHK:
10567     case BUILT_IN_MEMSET_CHK:
10568       return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10569                                       NULL_TREE, ignore,
10570                                       DECL_FUNCTION_CODE (fndecl));
10571
10572     case BUILT_IN_STRNCPY_CHK:
10573       return fold_builtin_strncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE);
10574
10575     case BUILT_IN_STRNCAT_CHK:
10576       return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
10577
10578     case BUILT_IN_FPRINTF_CHK:
10579     case BUILT_IN_VFPRINTF_CHK:
10580       if (!validate_arg (arg1, INTEGER_TYPE)
10581           || TREE_SIDE_EFFECTS (arg1))
10582         return NULL_TREE;
10583       else
10584         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
10585                                      ignore, fcode);
10586     break;
10587
10588     default:
10589       break;
10590     }
10591   return NULL_TREE;
10592 }
10593
10594 /* Fold a call to built-in function FNDECL.  ARGS is an array of NARGS
10595     arguments, where NARGS <= 4.  IGNORE is true if the result of the
10596     function call is ignored.  This function returns NULL_TREE if no
10597     simplification was possible.  Note that this only folds builtins with
10598     fixed argument patterns.  Foldings that do varargs-to-varargs
10599     transformations, or that match calls with more than 4 arguments,
10600     need to be handled with fold_builtin_varargs instead.  */
10601
10602 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10603
10604 static tree
10605 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
10606 {
10607   tree ret = NULL_TREE;
10608
10609   switch (nargs)
10610     {
10611     case 0:
10612       ret = fold_builtin_0 (loc, fndecl, ignore);
10613       break;
10614     case 1:
10615       ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
10616       break;
10617     case 2:
10618       ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
10619       break;
10620     case 3:
10621       ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
10622       break;
10623     case 4:
10624       ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
10625                             ignore);
10626       break;
10627     default:
10628       break;
10629     }
10630   if (ret)
10631     {
10632       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10633       SET_EXPR_LOCATION (ret, loc);
10634       TREE_NO_WARNING (ret) = 1;
10635       return ret;
10636     }
10637   return NULL_TREE;
10638 }
10639
10640 /* Builtins with folding operations that operate on "..." arguments
10641    need special handling; we need to store the arguments in a convenient
10642    data structure before attempting any folding.  Fortunately there are
10643    only a few builtins that fall into this category.  FNDECL is the
10644    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
10645    result of the function call is ignored.  */
10646
10647 static tree
10648 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
10649                       bool ignore ATTRIBUTE_UNUSED)
10650 {
10651   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10652   tree ret = NULL_TREE;
10653
10654   switch (fcode)
10655     {
10656     case BUILT_IN_SPRINTF_CHK:
10657     case BUILT_IN_VSPRINTF_CHK:
10658       ret = fold_builtin_sprintf_chk (loc, exp, fcode);
10659       break;
10660
10661     case BUILT_IN_SNPRINTF_CHK:
10662     case BUILT_IN_VSNPRINTF_CHK:
10663       ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
10664       break;
10665
10666     case BUILT_IN_FPCLASSIFY:
10667       ret = fold_builtin_fpclassify (loc, exp);
10668       break;
10669
10670     default:
10671       break;
10672     }
10673   if (ret)
10674     {
10675       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
10676       SET_EXPR_LOCATION (ret, loc);
10677       TREE_NO_WARNING (ret) = 1;
10678       return ret;
10679     }
10680   return NULL_TREE;
10681 }
10682
10683 /* Return true if FNDECL shouldn't be folded right now.
10684    If a built-in function has an inline attribute always_inline
10685    wrapper, defer folding it after always_inline functions have
10686    been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
10687    might not be performed.  */
10688
10689 static bool
10690 avoid_folding_inline_builtin (tree fndecl)
10691 {
10692   return (DECL_DECLARED_INLINE_P (fndecl)
10693           && DECL_DISREGARD_INLINE_LIMITS (fndecl)
10694           && cfun
10695           && !cfun->always_inline_functions_inlined
10696           && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
10697 }
10698
10699 /* A wrapper function for builtin folding that prevents warnings for
10700    "statement without effect" and the like, caused by removing the
10701    call node earlier than the warning is generated.  */
10702
10703 tree
10704 fold_call_expr (location_t loc, tree exp, bool ignore)
10705 {
10706   tree ret = NULL_TREE;
10707   tree fndecl = get_callee_fndecl (exp);
10708   if (fndecl
10709       && TREE_CODE (fndecl) == FUNCTION_DECL
10710       && DECL_BUILT_IN (fndecl)
10711       /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
10712          yet.  Defer folding until we see all the arguments
10713          (after inlining).  */
10714       && !CALL_EXPR_VA_ARG_PACK (exp))
10715     {
10716       int nargs = call_expr_nargs (exp);
10717
10718       /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
10719          instead last argument is __builtin_va_arg_pack ().  Defer folding
10720          even in that case, until arguments are finalized.  */
10721       if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
10722         {
10723           tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
10724           if (fndecl2
10725               && TREE_CODE (fndecl2) == FUNCTION_DECL
10726               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10727               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10728             return NULL_TREE;
10729         }
10730
10731       if (avoid_folding_inline_builtin (fndecl))
10732         return NULL_TREE;
10733
10734       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10735         return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
10736                                      CALL_EXPR_ARGP (exp), ignore);
10737       else
10738         {
10739           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
10740             {
10741               tree *args = CALL_EXPR_ARGP (exp);
10742               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
10743             }
10744           if (!ret)
10745             ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
10746           if (ret)
10747             return ret;
10748         }
10749     }
10750   return NULL_TREE;
10751 }
10752
10753 /* Conveniently construct a function call expression.  FNDECL names the
10754    function to be called and N arguments are passed in the array
10755    ARGARRAY.  */
10756
10757 tree
10758 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
10759 {
10760   tree fntype = TREE_TYPE (fndecl);
10761   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
10762
10763   return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
10764 }
10765
10766 /* Conveniently construct a function call expression.  FNDECL names the
10767    function to be called and the arguments are passed in the vector
10768    VEC.  */
10769
10770 tree
10771 build_call_expr_loc_vec (location_t loc, tree fndecl, VEC(tree,gc) *vec)
10772 {
10773   return build_call_expr_loc_array (loc, fndecl, VEC_length (tree, vec),
10774                                     VEC_address (tree, vec));
10775 }
10776
10777
10778 /* Conveniently construct a function call expression.  FNDECL names the
10779    function to be called, N is the number of arguments, and the "..."
10780    parameters are the argument expressions.  */
10781
10782 tree
10783 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
10784 {
10785   va_list ap;
10786   tree *argarray = XALLOCAVEC (tree, n);
10787   int i;
10788
10789   va_start (ap, n);
10790   for (i = 0; i < n; i++)
10791     argarray[i] = va_arg (ap, tree);
10792   va_end (ap);
10793   return build_call_expr_loc_array (loc, fndecl, n, argarray);
10794 }
10795
10796 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...).  Duplicated because
10797    varargs macros aren't supported by all bootstrap compilers.  */
10798
10799 tree
10800 build_call_expr (tree fndecl, int n, ...)
10801 {
10802   va_list ap;
10803   tree *argarray = XALLOCAVEC (tree, n);
10804   int i;
10805
10806   va_start (ap, n);
10807   for (i = 0; i < n; i++)
10808     argarray[i] = va_arg (ap, tree);
10809   va_end (ap);
10810   return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
10811 }
10812
10813 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
10814    N arguments are passed in the array ARGARRAY.  */
10815
10816 tree
10817 fold_builtin_call_array (location_t loc, tree type,
10818                          tree fn,
10819                          int n,
10820                          tree *argarray)
10821 {
10822   tree ret = NULL_TREE;
10823    tree exp;
10824
10825   if (TREE_CODE (fn) == ADDR_EXPR)
10826   {
10827     tree fndecl = TREE_OPERAND (fn, 0);
10828     if (TREE_CODE (fndecl) == FUNCTION_DECL
10829         && DECL_BUILT_IN (fndecl))
10830       {
10831         /* If last argument is __builtin_va_arg_pack (), arguments to this
10832            function are not finalized yet.  Defer folding until they are.  */
10833         if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
10834           {
10835             tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
10836             if (fndecl2
10837                 && TREE_CODE (fndecl2) == FUNCTION_DECL
10838                 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
10839                 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
10840               return build_call_array_loc (loc, type, fn, n, argarray);
10841           }
10842         if (avoid_folding_inline_builtin (fndecl))
10843           return build_call_array_loc (loc, type, fn, n, argarray);
10844         if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
10845           {
10846             ret = targetm.fold_builtin (fndecl, n, argarray, false);
10847             if (ret)
10848               return ret;
10849
10850             return build_call_array_loc (loc, type, fn, n, argarray);
10851           }
10852         else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
10853           {
10854             /* First try the transformations that don't require consing up
10855                an exp.  */
10856             ret = fold_builtin_n (loc, fndecl, argarray, n, false);
10857             if (ret)
10858               return ret;
10859           }
10860
10861         /* If we got this far, we need to build an exp.  */
10862         exp = build_call_array_loc (loc, type, fn, n, argarray);
10863         ret = fold_builtin_varargs (loc, fndecl, exp, false);
10864         return ret ? ret : exp;
10865       }
10866   }
10867
10868   return build_call_array_loc (loc, type, fn, n, argarray);
10869 }
10870
10871 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
10872    list ARGS along with N new arguments in NEWARGS.  SKIP is the number
10873    of arguments in ARGS to be omitted.  OLDNARGS is the number of
10874    elements in ARGS.  */
10875
10876 static tree
10877 rewrite_call_expr_valist (location_t loc, int oldnargs, tree *args,
10878                           int skip, tree fndecl, int n, va_list newargs)
10879 {
10880   int nargs = oldnargs - skip + n;
10881   tree *buffer;
10882
10883   if (n > 0)
10884     {
10885       int i, j;
10886
10887       buffer = XALLOCAVEC (tree, nargs);
10888       for (i = 0; i < n; i++)
10889         buffer[i] = va_arg (newargs, tree);
10890       for (j = skip; j < oldnargs; j++, i++)
10891         buffer[i] = args[j];
10892     }
10893   else
10894     buffer = args + skip;
10895
10896   return build_call_expr_loc_array (loc, fndecl, nargs, buffer);
10897 }
10898
10899 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
10900    list ARGS along with N new arguments specified as the "..."
10901    parameters.  SKIP is the number of arguments in ARGS to be omitted.
10902    OLDNARGS is the number of elements in ARGS.  */
10903
10904 static tree
10905 rewrite_call_expr_array (location_t loc, int oldnargs, tree *args,
10906                          int skip, tree fndecl, int n, ...)
10907 {
10908   va_list ap;
10909   tree t;
10910
10911   va_start (ap, n);
10912   t = rewrite_call_expr_valist (loc, oldnargs, args, skip, fndecl, n, ap);
10913   va_end (ap);
10914
10915   return t;
10916 }
10917
10918 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
10919    along with N new arguments specified as the "..." parameters.  SKIP
10920    is the number of arguments in EXP to be omitted.  This function is used
10921    to do varargs-to-varargs transformations.  */
10922
10923 static tree
10924 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
10925 {
10926   va_list ap;
10927   tree t;
10928
10929   va_start (ap, n);
10930   t = rewrite_call_expr_valist (loc, call_expr_nargs (exp),
10931                                 CALL_EXPR_ARGP (exp), skip, fndecl, n, ap);
10932   va_end (ap);
10933
10934   return t;
10935 }
10936
10937 /* Validate a single argument ARG against a tree code CODE representing
10938    a type.  */
10939
10940 static bool
10941 validate_arg (const_tree arg, enum tree_code code)
10942 {
10943   if (!arg)
10944     return false;
10945   else if (code == POINTER_TYPE)
10946     return POINTER_TYPE_P (TREE_TYPE (arg));
10947   else if (code == INTEGER_TYPE)
10948     return INTEGRAL_TYPE_P (TREE_TYPE (arg));
10949   return code == TREE_CODE (TREE_TYPE (arg));
10950 }
10951
10952 /* This function validates the types of a function call argument list
10953    against a specified list of tree_codes.  If the last specifier is a 0,
10954    that represents an ellipses, otherwise the last specifier must be a
10955    VOID_TYPE.
10956
10957    This is the GIMPLE version of validate_arglist.  Eventually we want to
10958    completely convert builtins.c to work from GIMPLEs and the tree based
10959    validate_arglist will then be removed.  */
10960
10961 bool
10962 validate_gimple_arglist (const_gimple call, ...)
10963 {
10964   enum tree_code code;
10965   bool res = 0;
10966   va_list ap;
10967   const_tree arg;
10968   size_t i;
10969
10970   va_start (ap, call);
10971   i = 0;
10972
10973   do
10974     {
10975       code = (enum tree_code) va_arg (ap, int);
10976       switch (code)
10977         {
10978         case 0:
10979           /* This signifies an ellipses, any further arguments are all ok.  */
10980           res = true;
10981           goto end;
10982         case VOID_TYPE:
10983           /* This signifies an endlink, if no arguments remain, return
10984              true, otherwise return false.  */
10985           res = (i == gimple_call_num_args (call));
10986           goto end;
10987         default:
10988           /* If no parameters remain or the parameter's code does not
10989              match the specified code, return false.  Otherwise continue
10990              checking any remaining arguments.  */
10991           arg = gimple_call_arg (call, i++);
10992           if (!validate_arg (arg, code))
10993             goto end;
10994           break;
10995         }
10996     }
10997   while (1);
10998
10999   /* We need gotos here since we can only have one VA_CLOSE in a
11000      function.  */
11001  end: ;
11002   va_end (ap);
11003
11004   return res;
11005 }
11006
11007 /* This function validates the types of a function call argument list
11008    against a specified list of tree_codes.  If the last specifier is a 0,
11009    that represents an ellipses, otherwise the last specifier must be a
11010    VOID_TYPE.  */
11011
11012 bool
11013 validate_arglist (const_tree callexpr, ...)
11014 {
11015   enum tree_code code;
11016   bool res = 0;
11017   va_list ap;
11018   const_call_expr_arg_iterator iter;
11019   const_tree arg;
11020
11021   va_start (ap, callexpr);
11022   init_const_call_expr_arg_iterator (callexpr, &iter);
11023
11024   do
11025     {
11026       code = (enum tree_code) va_arg (ap, int);
11027       switch (code)
11028         {
11029         case 0:
11030           /* This signifies an ellipses, any further arguments are all ok.  */
11031           res = true;
11032           goto end;
11033         case VOID_TYPE:
11034           /* This signifies an endlink, if no arguments remain, return
11035              true, otherwise return false.  */
11036           res = !more_const_call_expr_args_p (&iter);
11037           goto end;
11038         default:
11039           /* If no parameters remain or the parameter's code does not
11040              match the specified code, return false.  Otherwise continue
11041              checking any remaining arguments.  */
11042           arg = next_const_call_expr_arg (&iter);
11043           if (!validate_arg (arg, code))
11044             goto end;
11045           break;
11046         }
11047     }
11048   while (1);
11049
11050   /* We need gotos here since we can only have one VA_CLOSE in a
11051      function.  */
11052  end: ;
11053   va_end (ap);
11054
11055   return res;
11056 }
11057
11058 /* Default target-specific builtin expander that does nothing.  */
11059
11060 rtx
11061 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11062                         rtx target ATTRIBUTE_UNUSED,
11063                         rtx subtarget ATTRIBUTE_UNUSED,
11064                         enum machine_mode mode ATTRIBUTE_UNUSED,
11065                         int ignore ATTRIBUTE_UNUSED)
11066 {
11067   return NULL_RTX;
11068 }
11069
11070 /* Returns true is EXP represents data that would potentially reside
11071    in a readonly section.  */
11072
11073 static bool
11074 readonly_data_expr (tree exp)
11075 {
11076   STRIP_NOPS (exp);
11077
11078   if (TREE_CODE (exp) != ADDR_EXPR)
11079     return false;
11080
11081   exp = get_base_address (TREE_OPERAND (exp, 0));
11082   if (!exp)
11083     return false;
11084
11085   /* Make sure we call decl_readonly_section only for trees it
11086      can handle (since it returns true for everything it doesn't
11087      understand).  */
11088   if (TREE_CODE (exp) == STRING_CST
11089       || TREE_CODE (exp) == CONSTRUCTOR
11090       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11091     return decl_readonly_section (exp, 0);
11092   else
11093     return false;
11094 }
11095
11096 /* Simplify a call to the strstr builtin.  S1 and S2 are the arguments
11097    to the call, and TYPE is its return type.
11098
11099    Return NULL_TREE if no simplification was possible, otherwise return the
11100    simplified form of the call as a tree.
11101
11102    The simplified form may be a constant or other expression which
11103    computes the same value, but in a more efficient manner (including
11104    calls to other builtin functions).
11105
11106    The call may contain arguments which need to be evaluated, but
11107    which are not useful to determine the result of the call.  In
11108    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11109    COMPOUND_EXPR will be an argument which must be evaluated.
11110    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11111    COMPOUND_EXPR in the chain will contain the tree for the simplified
11112    form of the builtin function call.  */
11113
11114 static tree
11115 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11116 {
11117   if (!validate_arg (s1, POINTER_TYPE)
11118       || !validate_arg (s2, POINTER_TYPE))
11119     return NULL_TREE;
11120   else
11121     {
11122       tree fn;
11123       const char *p1, *p2;
11124
11125       p2 = c_getstr (s2);
11126       if (p2 == NULL)
11127         return NULL_TREE;
11128
11129       p1 = c_getstr (s1);
11130       if (p1 != NULL)
11131         {
11132           const char *r = strstr (p1, p2);
11133           tree tem;
11134
11135           if (r == NULL)
11136             return build_int_cst (TREE_TYPE (s1), 0);
11137
11138           /* Return an offset into the constant string argument.  */
11139           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11140                              s1, size_int (r - p1));
11141           return fold_convert_loc (loc, type, tem);
11142         }
11143
11144       /* The argument is const char *, and the result is char *, so we need
11145          a type conversion here to avoid a warning.  */
11146       if (p2[0] == '\0')
11147         return fold_convert_loc (loc, type, s1);
11148
11149       if (p2[1] != '\0')
11150         return NULL_TREE;
11151
11152       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11153       if (!fn)
11154         return NULL_TREE;
11155
11156       /* New argument list transforming strstr(s1, s2) to
11157          strchr(s1, s2[0]).  */
11158       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11159     }
11160 }
11161
11162 /* Simplify a call to the strchr builtin.  S1 and S2 are the arguments to
11163    the call, and TYPE is its return type.
11164
11165    Return NULL_TREE if no simplification was possible, otherwise return the
11166    simplified form of the call as a tree.
11167
11168    The simplified form may be a constant or other expression which
11169    computes the same value, but in a more efficient manner (including
11170    calls to other builtin functions).
11171
11172    The call may contain arguments which need to be evaluated, but
11173    which are not useful to determine the result of the call.  In
11174    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11175    COMPOUND_EXPR will be an argument which must be evaluated.
11176    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11177    COMPOUND_EXPR in the chain will contain the tree for the simplified
11178    form of the builtin function call.  */
11179
11180 static tree
11181 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11182 {
11183   if (!validate_arg (s1, POINTER_TYPE)
11184       || !validate_arg (s2, INTEGER_TYPE))
11185     return NULL_TREE;
11186   else
11187     {
11188       const char *p1;
11189
11190       if (TREE_CODE (s2) != INTEGER_CST)
11191         return NULL_TREE;
11192
11193       p1 = c_getstr (s1);
11194       if (p1 != NULL)
11195         {
11196           char c;
11197           const char *r;
11198           tree tem;
11199
11200           if (target_char_cast (s2, &c))
11201             return NULL_TREE;
11202
11203           r = strchr (p1, c);
11204
11205           if (r == NULL)
11206             return build_int_cst (TREE_TYPE (s1), 0);
11207
11208           /* Return an offset into the constant string argument.  */
11209           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11210                              s1, size_int (r - p1));
11211           return fold_convert_loc (loc, type, tem);
11212         }
11213       return NULL_TREE;
11214     }
11215 }
11216
11217 /* Simplify a call to the strrchr builtin.  S1 and S2 are the arguments to
11218    the call, and TYPE is its return type.
11219
11220    Return NULL_TREE if no simplification was possible, otherwise return the
11221    simplified form of the call as a tree.
11222
11223    The simplified form may be a constant or other expression which
11224    computes the same value, but in a more efficient manner (including
11225    calls to other builtin functions).
11226
11227    The call may contain arguments which need to be evaluated, but
11228    which are not useful to determine the result of the call.  In
11229    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11230    COMPOUND_EXPR will be an argument which must be evaluated.
11231    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11232    COMPOUND_EXPR in the chain will contain the tree for the simplified
11233    form of the builtin function call.  */
11234
11235 static tree
11236 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11237 {
11238   if (!validate_arg (s1, POINTER_TYPE)
11239       || !validate_arg (s2, INTEGER_TYPE))
11240     return NULL_TREE;
11241   else
11242     {
11243       tree fn;
11244       const char *p1;
11245
11246       if (TREE_CODE (s2) != INTEGER_CST)
11247         return NULL_TREE;
11248
11249       p1 = c_getstr (s1);
11250       if (p1 != NULL)
11251         {
11252           char c;
11253           const char *r;
11254           tree tem;
11255
11256           if (target_char_cast (s2, &c))
11257             return NULL_TREE;
11258
11259           r = strrchr (p1, c);
11260
11261           if (r == NULL)
11262             return build_int_cst (TREE_TYPE (s1), 0);
11263
11264           /* Return an offset into the constant string argument.  */
11265           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11266                              s1, size_int (r - p1));
11267           return fold_convert_loc (loc, type, tem);
11268         }
11269
11270       if (! integer_zerop (s2))
11271         return NULL_TREE;
11272
11273       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11274       if (!fn)
11275         return NULL_TREE;
11276
11277       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
11278       return build_call_expr_loc (loc, fn, 2, s1, s2);
11279     }
11280 }
11281
11282 /* Simplify a call to the strpbrk builtin.  S1 and S2 are the arguments
11283    to the call, and TYPE is its return type.
11284
11285    Return NULL_TREE if no simplification was possible, otherwise return the
11286    simplified form of the call as a tree.
11287
11288    The simplified form may be a constant or other expression which
11289    computes the same value, but in a more efficient manner (including
11290    calls to other builtin functions).
11291
11292    The call may contain arguments which need to be evaluated, but
11293    which are not useful to determine the result of the call.  In
11294    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11295    COMPOUND_EXPR will be an argument which must be evaluated.
11296    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11297    COMPOUND_EXPR in the chain will contain the tree for the simplified
11298    form of the builtin function call.  */
11299
11300 static tree
11301 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11302 {
11303   if (!validate_arg (s1, POINTER_TYPE)
11304       || !validate_arg (s2, POINTER_TYPE))
11305     return NULL_TREE;
11306   else
11307     {
11308       tree fn;
11309       const char *p1, *p2;
11310
11311       p2 = c_getstr (s2);
11312       if (p2 == NULL)
11313         return NULL_TREE;
11314
11315       p1 = c_getstr (s1);
11316       if (p1 != NULL)
11317         {
11318           const char *r = strpbrk (p1, p2);
11319           tree tem;
11320
11321           if (r == NULL)
11322             return build_int_cst (TREE_TYPE (s1), 0);
11323
11324           /* Return an offset into the constant string argument.  */
11325           tem = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (s1),
11326                              s1, size_int (r - p1));
11327           return fold_convert_loc (loc, type, tem);
11328         }
11329
11330       if (p2[0] == '\0')
11331         /* strpbrk(x, "") == NULL.
11332            Evaluate and ignore s1 in case it had side-effects.  */
11333         return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11334
11335       if (p2[1] != '\0')
11336         return NULL_TREE;  /* Really call strpbrk.  */
11337
11338       fn = implicit_built_in_decls[BUILT_IN_STRCHR];
11339       if (!fn)
11340         return NULL_TREE;
11341
11342       /* New argument list transforming strpbrk(s1, s2) to
11343          strchr(s1, s2[0]).  */
11344       return build_call_expr_loc (loc, fn, 2, s1, build_int_cst (NULL_TREE, p2[0]));
11345     }
11346 }
11347
11348 /* Simplify a call to the strcat builtin.  DST and SRC are the arguments
11349    to the call.
11350
11351    Return NULL_TREE if no simplification was possible, otherwise return the
11352    simplified form of the call as a tree.
11353
11354    The simplified form may be a constant or other expression which
11355    computes the same value, but in a more efficient manner (including
11356    calls to other builtin functions).
11357
11358    The call may contain arguments which need to be evaluated, but
11359    which are not useful to determine the result of the call.  In
11360    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11361    COMPOUND_EXPR will be an argument which must be evaluated.
11362    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11363    COMPOUND_EXPR in the chain will contain the tree for the simplified
11364    form of the builtin function call.  */
11365
11366 static tree
11367 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11368 {
11369   if (!validate_arg (dst, POINTER_TYPE)
11370       || !validate_arg (src, POINTER_TYPE))
11371     return NULL_TREE;
11372   else
11373     {
11374       const char *p = c_getstr (src);
11375
11376       /* If the string length is zero, return the dst parameter.  */
11377       if (p && *p == '\0')
11378         return dst;
11379
11380       if (optimize_insn_for_speed_p ())
11381         {
11382           /* See if we can store by pieces into (dst + strlen(dst)).  */
11383           tree newdst, call;
11384           tree strlen_fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11385           tree strcpy_fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11386
11387           if (!strlen_fn || !strcpy_fn)
11388             return NULL_TREE;
11389
11390           /* If we don't have a movstr we don't want to emit an strcpy
11391              call.  We have to do that if the length of the source string
11392              isn't computable (in that case we can use memcpy probably
11393              later expanding to a sequence of mov instructions).  If we
11394              have movstr instructions we can emit strcpy calls.  */
11395           if (!HAVE_movstr)
11396             {
11397               tree len = c_strlen (src, 1);
11398               if (! len || TREE_SIDE_EFFECTS (len))
11399                 return NULL_TREE;
11400             }
11401
11402           /* Stabilize the argument list.  */
11403           dst = builtin_save_expr (dst);
11404
11405           /* Create strlen (dst).  */
11406           newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11407           /* Create (dst p+ strlen (dst)).  */
11408
11409           newdst = fold_build2_loc (loc, POINTER_PLUS_EXPR,
11410                                 TREE_TYPE (dst), dst, newdst);
11411           newdst = builtin_save_expr (newdst);
11412
11413           call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11414           return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11415         }
11416       return NULL_TREE;
11417     }
11418 }
11419
11420 /* Simplify a call to the strncat builtin.  DST, SRC, and LEN are the
11421    arguments to the call.
11422
11423    Return NULL_TREE if no simplification was possible, otherwise return the
11424    simplified form of the call as a tree.
11425
11426    The simplified form may be a constant or other expression which
11427    computes the same value, but in a more efficient manner (including
11428    calls to other builtin functions).
11429
11430    The call may contain arguments which need to be evaluated, but
11431    which are not useful to determine the result of the call.  In
11432    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11433    COMPOUND_EXPR will be an argument which must be evaluated.
11434    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11435    COMPOUND_EXPR in the chain will contain the tree for the simplified
11436    form of the builtin function call.  */
11437
11438 static tree
11439 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11440 {
11441   if (!validate_arg (dst, POINTER_TYPE)
11442       || !validate_arg (src, POINTER_TYPE)
11443       || !validate_arg (len, INTEGER_TYPE))
11444     return NULL_TREE;
11445   else
11446     {
11447       const char *p = c_getstr (src);
11448
11449       /* If the requested length is zero, or the src parameter string
11450          length is zero, return the dst parameter.  */
11451       if (integer_zerop (len) || (p && *p == '\0'))
11452         return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11453
11454       /* If the requested len is greater than or equal to the string
11455          length, call strcat.  */
11456       if (TREE_CODE (len) == INTEGER_CST && p
11457           && compare_tree_int (len, strlen (p)) >= 0)
11458         {
11459           tree fn = implicit_built_in_decls[BUILT_IN_STRCAT];
11460
11461           /* If the replacement _DECL isn't initialized, don't do the
11462              transformation.  */
11463           if (!fn)
11464             return NULL_TREE;
11465
11466           return build_call_expr_loc (loc, fn, 2, dst, src);
11467         }
11468       return NULL_TREE;
11469     }
11470 }
11471
11472 /* Simplify a call to the strspn builtin.  S1 and S2 are the arguments
11473    to the call.
11474
11475    Return NULL_TREE if no simplification was possible, otherwise return the
11476    simplified form of the call as a tree.
11477
11478    The simplified form may be a constant or other expression which
11479    computes the same value, but in a more efficient manner (including
11480    calls to other builtin functions).
11481
11482    The call may contain arguments which need to be evaluated, but
11483    which are not useful to determine the result of the call.  In
11484    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11485    COMPOUND_EXPR will be an argument which must be evaluated.
11486    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11487    COMPOUND_EXPR in the chain will contain the tree for the simplified
11488    form of the builtin function call.  */
11489
11490 static tree
11491 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11492 {
11493   if (!validate_arg (s1, POINTER_TYPE)
11494       || !validate_arg (s2, POINTER_TYPE))
11495     return NULL_TREE;
11496   else
11497     {
11498       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11499
11500       /* If both arguments are constants, evaluate at compile-time.  */
11501       if (p1 && p2)
11502         {
11503           const size_t r = strspn (p1, p2);
11504           return size_int (r);
11505         }
11506
11507       /* If either argument is "", return NULL_TREE.  */
11508       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11509         /* Evaluate and ignore both arguments in case either one has
11510            side-effects.  */
11511         return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11512                                   s1, s2);
11513       return NULL_TREE;
11514     }
11515 }
11516
11517 /* Simplify a call to the strcspn builtin.  S1 and S2 are the arguments
11518    to the call.
11519
11520    Return NULL_TREE if no simplification was possible, otherwise return the
11521    simplified form of the call as a tree.
11522
11523    The simplified form may be a constant or other expression which
11524    computes the same value, but in a more efficient manner (including
11525    calls to other builtin functions).
11526
11527    The call may contain arguments which need to be evaluated, but
11528    which are not useful to determine the result of the call.  In
11529    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11530    COMPOUND_EXPR will be an argument which must be evaluated.
11531    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11532    COMPOUND_EXPR in the chain will contain the tree for the simplified
11533    form of the builtin function call.  */
11534
11535 static tree
11536 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11537 {
11538   if (!validate_arg (s1, POINTER_TYPE)
11539       || !validate_arg (s2, POINTER_TYPE))
11540     return NULL_TREE;
11541   else
11542     {
11543       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11544
11545       /* If both arguments are constants, evaluate at compile-time.  */
11546       if (p1 && p2)
11547         {
11548           const size_t r = strcspn (p1, p2);
11549           return size_int (r);
11550         }
11551
11552       /* If the first argument is "", return NULL_TREE.  */
11553       if (p1 && *p1 == '\0')
11554         {
11555           /* Evaluate and ignore argument s2 in case it has
11556              side-effects.  */
11557           return omit_one_operand_loc (loc, size_type_node,
11558                                    size_zero_node, s2);
11559         }
11560
11561       /* If the second argument is "", return __builtin_strlen(s1).  */
11562       if (p2 && *p2 == '\0')
11563         {
11564           tree fn = implicit_built_in_decls[BUILT_IN_STRLEN];
11565
11566           /* If the replacement _DECL isn't initialized, don't do the
11567              transformation.  */
11568           if (!fn)
11569             return NULL_TREE;
11570
11571           return build_call_expr_loc (loc, fn, 1, s1);
11572         }
11573       return NULL_TREE;
11574     }
11575 }
11576
11577 /* Fold a call to the fputs builtin.  ARG0 and ARG1 are the arguments
11578    to the call.  IGNORE is true if the value returned
11579    by the builtin will be ignored.  UNLOCKED is true is true if this
11580    actually a call to fputs_unlocked.  If LEN in non-NULL, it represents
11581    the known length of the string.  Return NULL_TREE if no simplification
11582    was possible.  */
11583
11584 tree
11585 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
11586                     bool ignore, bool unlocked, tree len)
11587 {
11588   /* If we're using an unlocked function, assume the other unlocked
11589      functions exist explicitly.  */
11590   tree const fn_fputc = unlocked ? built_in_decls[BUILT_IN_FPUTC_UNLOCKED]
11591     : implicit_built_in_decls[BUILT_IN_FPUTC];
11592   tree const fn_fwrite = unlocked ? built_in_decls[BUILT_IN_FWRITE_UNLOCKED]
11593     : implicit_built_in_decls[BUILT_IN_FWRITE];
11594
11595   /* If the return value is used, don't do the transformation.  */
11596   if (!ignore)
11597     return NULL_TREE;
11598
11599   /* Verify the arguments in the original call.  */
11600   if (!validate_arg (arg0, POINTER_TYPE)
11601       || !validate_arg (arg1, POINTER_TYPE))
11602     return NULL_TREE;
11603
11604   if (! len)
11605     len = c_strlen (arg0, 0);
11606
11607   /* Get the length of the string passed to fputs.  If the length
11608      can't be determined, punt.  */
11609   if (!len
11610       || TREE_CODE (len) != INTEGER_CST)
11611     return NULL_TREE;
11612
11613   switch (compare_tree_int (len, 1))
11614     {
11615     case -1: /* length is 0, delete the call entirely .  */
11616       return omit_one_operand_loc (loc, integer_type_node,
11617                                integer_zero_node, arg1);;
11618
11619     case 0: /* length is 1, call fputc.  */
11620       {
11621         const char *p = c_getstr (arg0);
11622
11623         if (p != NULL)
11624           {
11625             if (fn_fputc)
11626               return build_call_expr_loc (loc, fn_fputc, 2,
11627                                       build_int_cst (NULL_TREE, p[0]), arg1);
11628             else
11629               return NULL_TREE;
11630           }
11631       }
11632       /* FALLTHROUGH */
11633     case 1: /* length is greater than 1, call fwrite.  */
11634       {
11635         /* If optimizing for size keep fputs.  */
11636         if (optimize_function_for_size_p (cfun))
11637           return NULL_TREE;
11638         /* New argument list transforming fputs(string, stream) to
11639            fwrite(string, 1, len, stream).  */
11640         if (fn_fwrite)
11641           return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
11642                                   size_one_node, len, arg1);
11643         else
11644           return NULL_TREE;
11645       }
11646     default:
11647       gcc_unreachable ();
11648     }
11649   return NULL_TREE;
11650 }
11651
11652 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
11653    produced.  False otherwise.  This is done so that we don't output the error
11654    or warning twice or three times.  */
11655
11656 bool
11657 fold_builtin_next_arg (tree exp, bool va_start_p)
11658 {
11659   tree fntype = TREE_TYPE (current_function_decl);
11660   int nargs = call_expr_nargs (exp);
11661   tree arg;
11662
11663   if (!stdarg_p (fntype))
11664     {
11665       error ("%<va_start%> used in function with fixed args");
11666       return true;
11667     }
11668
11669   if (va_start_p)
11670     {
11671       if (va_start_p && (nargs != 2))
11672         {
11673           error ("wrong number of arguments to function %<va_start%>");
11674           return true;
11675         }
11676       arg = CALL_EXPR_ARG (exp, 1);
11677     }
11678   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
11679      when we checked the arguments and if needed issued a warning.  */
11680   else
11681     {
11682       if (nargs == 0)
11683         {
11684           /* Evidently an out of date version of <stdarg.h>; can't validate
11685              va_start's second argument, but can still work as intended.  */
11686           warning (0, "%<__builtin_next_arg%> called without an argument");
11687           return true;
11688         }
11689       else if (nargs > 1)
11690         {
11691           error ("wrong number of arguments to function %<__builtin_next_arg%>");
11692           return true;
11693         }
11694       arg = CALL_EXPR_ARG (exp, 0);
11695     }
11696
11697   if (TREE_CODE (arg) == SSA_NAME)
11698     arg = SSA_NAME_VAR (arg);
11699
11700   /* We destructively modify the call to be __builtin_va_start (ap, 0)
11701      or __builtin_next_arg (0) the first time we see it, after checking
11702      the arguments and if needed issuing a warning.  */
11703   if (!integer_zerop (arg))
11704     {
11705       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
11706
11707       /* Strip off all nops for the sake of the comparison.  This
11708          is not quite the same as STRIP_NOPS.  It does more.
11709          We must also strip off INDIRECT_EXPR for C++ reference
11710          parameters.  */
11711       while (CONVERT_EXPR_P (arg)
11712              || TREE_CODE (arg) == INDIRECT_REF)
11713         arg = TREE_OPERAND (arg, 0);
11714       if (arg != last_parm)
11715         {
11716           /* FIXME: Sometimes with the tree optimizers we can get the
11717              not the last argument even though the user used the last
11718              argument.  We just warn and set the arg to be the last
11719              argument so that we will get wrong-code because of
11720              it.  */
11721           warning (0, "second parameter of %<va_start%> not last named argument");
11722         }
11723
11724       /* Undefined by C99 7.15.1.4p4 (va_start):
11725          "If the parameter parmN is declared with the register storage
11726          class, with a function or array type, or with a type that is
11727          not compatible with the type that results after application of
11728          the default argument promotions, the behavior is undefined."
11729       */
11730       else if (DECL_REGISTER (arg))
11731         warning (0, "undefined behaviour when second parameter of "
11732                  "%<va_start%> is declared with %<register%> storage");
11733
11734       /* We want to verify the second parameter just once before the tree
11735          optimizers are run and then avoid keeping it in the tree,
11736          as otherwise we could warn even for correct code like:
11737          void foo (int i, ...)
11738          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
11739       if (va_start_p)
11740         CALL_EXPR_ARG (exp, 1) = integer_zero_node;
11741       else
11742         CALL_EXPR_ARG (exp, 0) = integer_zero_node;
11743     }
11744   return false;
11745 }
11746
11747
11748 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
11749    ORIG may be null if this is a 2-argument call.  We don't attempt to
11750    simplify calls with more than 3 arguments.
11751
11752    Return NULL_TREE if no simplification was possible, otherwise return the
11753    simplified form of the call as a tree.  If IGNORED is true, it means that
11754    the caller does not use the returned value of the function.  */
11755
11756 static tree
11757 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
11758                       tree orig, int ignored)
11759 {
11760   tree call, retval;
11761   const char *fmt_str = NULL;
11762
11763   /* Verify the required arguments in the original call.  We deal with two
11764      types of sprintf() calls: 'sprintf (str, fmt)' and
11765      'sprintf (dest, "%s", orig)'.  */
11766   if (!validate_arg (dest, POINTER_TYPE)
11767       || !validate_arg (fmt, POINTER_TYPE))
11768     return NULL_TREE;
11769   if (orig && !validate_arg (orig, POINTER_TYPE))
11770     return NULL_TREE;
11771
11772   /* Check whether the format is a literal string constant.  */
11773   fmt_str = c_getstr (fmt);
11774   if (fmt_str == NULL)
11775     return NULL_TREE;
11776
11777   call = NULL_TREE;
11778   retval = NULL_TREE;
11779
11780   if (!init_target_chars ())
11781     return NULL_TREE;
11782
11783   /* If the format doesn't contain % args or %%, use strcpy.  */
11784   if (strchr (fmt_str, target_percent) == NULL)
11785     {
11786       tree fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11787
11788       if (!fn)
11789         return NULL_TREE;
11790
11791       /* Don't optimize sprintf (buf, "abc", ptr++).  */
11792       if (orig)
11793         return NULL_TREE;
11794
11795       /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
11796          'format' is known to contain no % formats.  */
11797       call = build_call_expr_loc (loc, fn, 2, dest, fmt);
11798       if (!ignored)
11799         retval = build_int_cst (NULL_TREE, strlen (fmt_str));
11800     }
11801
11802   /* If the format is "%s", use strcpy if the result isn't used.  */
11803   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
11804     {
11805       tree fn;
11806       fn = implicit_built_in_decls[BUILT_IN_STRCPY];
11807
11808       if (!fn)
11809         return NULL_TREE;
11810
11811       /* Don't crash on sprintf (str1, "%s").  */
11812       if (!orig)
11813         return NULL_TREE;
11814
11815       /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2).  */
11816       if (!ignored)
11817         {
11818           retval = c_strlen (orig, 1);
11819           if (!retval || TREE_CODE (retval) != INTEGER_CST)
11820             return NULL_TREE;
11821         }
11822       call = build_call_expr_loc (loc, fn, 2, dest, orig);
11823     }
11824
11825   if (call && retval)
11826     {
11827       retval = fold_convert_loc
11828         (loc, TREE_TYPE (TREE_TYPE (implicit_built_in_decls[BUILT_IN_SPRINTF])),
11829          retval);
11830       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
11831     }
11832   else
11833     return call;
11834 }
11835
11836 /* Expand a call EXP to __builtin_object_size.  */
11837
11838 rtx
11839 expand_builtin_object_size (tree exp)
11840 {
11841   tree ost;
11842   int object_size_type;
11843   tree fndecl = get_callee_fndecl (exp);
11844
11845   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
11846     {
11847       error ("%Kfirst argument of %D must be a pointer, second integer constant",
11848              exp, fndecl);
11849       expand_builtin_trap ();
11850       return const0_rtx;
11851     }
11852
11853   ost = CALL_EXPR_ARG (exp, 1);
11854   STRIP_NOPS (ost);
11855
11856   if (TREE_CODE (ost) != INTEGER_CST
11857       || tree_int_cst_sgn (ost) < 0
11858       || compare_tree_int (ost, 3) > 0)
11859     {
11860       error ("%Klast argument of %D is not integer constant between 0 and 3",
11861              exp, fndecl);
11862       expand_builtin_trap ();
11863       return const0_rtx;
11864     }
11865
11866   object_size_type = tree_low_cst (ost, 0);
11867
11868   return object_size_type < 2 ? constm1_rtx : const0_rtx;
11869 }
11870
11871 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
11872    FCODE is the BUILT_IN_* to use.
11873    Return NULL_RTX if we failed; the caller should emit a normal call,
11874    otherwise try to get the result in TARGET, if convenient (and in
11875    mode MODE if that's convenient).  */
11876
11877 static rtx
11878 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
11879                            enum built_in_function fcode)
11880 {
11881   tree dest, src, len, size;
11882
11883   if (!validate_arglist (exp,
11884                          POINTER_TYPE,
11885                          fcode == BUILT_IN_MEMSET_CHK
11886                          ? INTEGER_TYPE : POINTER_TYPE,
11887                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
11888     return NULL_RTX;
11889
11890   dest = CALL_EXPR_ARG (exp, 0);
11891   src = CALL_EXPR_ARG (exp, 1);
11892   len = CALL_EXPR_ARG (exp, 2);
11893   size = CALL_EXPR_ARG (exp, 3);
11894
11895   if (! host_integerp (size, 1))
11896     return NULL_RTX;
11897
11898   if (host_integerp (len, 1) || integer_all_onesp (size))
11899     {
11900       tree fn;
11901
11902       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
11903         {
11904           warning_at (tree_nonartificial_location (exp),
11905                       0, "%Kcall to %D will always overflow destination buffer",
11906                       exp, get_callee_fndecl (exp));
11907           return NULL_RTX;
11908         }
11909
11910       fn = NULL_TREE;
11911       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
11912          mem{cpy,pcpy,move,set} is available.  */
11913       switch (fcode)
11914         {
11915         case BUILT_IN_MEMCPY_CHK:
11916           fn = built_in_decls[BUILT_IN_MEMCPY];
11917           break;
11918         case BUILT_IN_MEMPCPY_CHK:
11919           fn = built_in_decls[BUILT_IN_MEMPCPY];
11920           break;
11921         case BUILT_IN_MEMMOVE_CHK:
11922           fn = built_in_decls[BUILT_IN_MEMMOVE];
11923           break;
11924         case BUILT_IN_MEMSET_CHK:
11925           fn = built_in_decls[BUILT_IN_MEMSET];
11926           break;
11927         default:
11928           break;
11929         }
11930
11931       if (! fn)
11932         return NULL_RTX;
11933
11934       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
11935       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
11936       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11937       return expand_expr (fn, target, mode, EXPAND_NORMAL);
11938     }
11939   else if (fcode == BUILT_IN_MEMSET_CHK)
11940     return NULL_RTX;
11941   else
11942     {
11943       unsigned int dest_align
11944         = get_pointer_alignment (dest, BIGGEST_ALIGNMENT);
11945
11946       /* If DEST is not a pointer type, call the normal function.  */
11947       if (dest_align == 0)
11948         return NULL_RTX;
11949
11950       /* If SRC and DEST are the same (and not volatile), do nothing.  */
11951       if (operand_equal_p (src, dest, 0))
11952         {
11953           tree expr;
11954
11955           if (fcode != BUILT_IN_MEMPCPY_CHK)
11956             {
11957               /* Evaluate and ignore LEN in case it has side-effects.  */
11958               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
11959               return expand_expr (dest, target, mode, EXPAND_NORMAL);
11960             }
11961
11962           expr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (dest), dest, len);
11963           return expand_expr (expr, target, mode, EXPAND_NORMAL);
11964         }
11965
11966       /* __memmove_chk special case.  */
11967       if (fcode == BUILT_IN_MEMMOVE_CHK)
11968         {
11969           unsigned int src_align
11970             = get_pointer_alignment (src, BIGGEST_ALIGNMENT);
11971
11972           if (src_align == 0)
11973             return NULL_RTX;
11974
11975           /* If src is categorized for a readonly section we can use
11976              normal __memcpy_chk.  */
11977           if (readonly_data_expr (src))
11978             {
11979               tree fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
11980               if (!fn)
11981                 return NULL_RTX;
11982               fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
11983                                           dest, src, len, size);
11984               gcc_assert (TREE_CODE (fn) == CALL_EXPR);
11985               CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
11986               return expand_expr (fn, target, mode, EXPAND_NORMAL);
11987             }
11988         }
11989       return NULL_RTX;
11990     }
11991 }
11992
11993 /* Emit warning if a buffer overflow is detected at compile time.  */
11994
11995 static void
11996 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
11997 {
11998   int is_strlen = 0;
11999   tree len, size;
12000   location_t loc = tree_nonartificial_location (exp);
12001
12002   switch (fcode)
12003     {
12004     case BUILT_IN_STRCPY_CHK:
12005     case BUILT_IN_STPCPY_CHK:
12006     /* For __strcat_chk the warning will be emitted only if overflowing
12007        by at least strlen (dest) + 1 bytes.  */
12008     case BUILT_IN_STRCAT_CHK:
12009       len = CALL_EXPR_ARG (exp, 1);
12010       size = CALL_EXPR_ARG (exp, 2);
12011       is_strlen = 1;
12012       break;
12013     case BUILT_IN_STRNCAT_CHK:
12014     case BUILT_IN_STRNCPY_CHK:
12015       len = CALL_EXPR_ARG (exp, 2);
12016       size = CALL_EXPR_ARG (exp, 3);
12017       break;
12018     case BUILT_IN_SNPRINTF_CHK:
12019     case BUILT_IN_VSNPRINTF_CHK:
12020       len = CALL_EXPR_ARG (exp, 1);
12021       size = CALL_EXPR_ARG (exp, 3);
12022       break;
12023     default:
12024       gcc_unreachable ();
12025     }
12026
12027   if (!len || !size)
12028     return;
12029
12030   if (! host_integerp (size, 1) || integer_all_onesp (size))
12031     return;
12032
12033   if (is_strlen)
12034     {
12035       len = c_strlen (len, 1);
12036       if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12037         return;
12038     }
12039   else if (fcode == BUILT_IN_STRNCAT_CHK)
12040     {
12041       tree src = CALL_EXPR_ARG (exp, 1);
12042       if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12043         return;
12044       src = c_strlen (src, 1);
12045       if (! src || ! host_integerp (src, 1))
12046         {
12047           warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12048                       exp, get_callee_fndecl (exp));
12049           return;
12050         }
12051       else if (tree_int_cst_lt (src, size))
12052         return;
12053     }
12054   else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12055     return;
12056
12057   warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12058               exp, get_callee_fndecl (exp));
12059 }
12060
12061 /* Emit warning if a buffer overflow is detected at compile time
12062    in __sprintf_chk/__vsprintf_chk calls.  */
12063
12064 static void
12065 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12066 {
12067   tree size, len, fmt;
12068   const char *fmt_str;
12069   int nargs = call_expr_nargs (exp);
12070
12071   /* Verify the required arguments in the original call.  */
12072
12073   if (nargs < 4)
12074     return;
12075   size = CALL_EXPR_ARG (exp, 2);
12076   fmt = CALL_EXPR_ARG (exp, 3);
12077
12078   if (! host_integerp (size, 1) || integer_all_onesp (size))
12079     return;
12080
12081   /* Check whether the format is a literal string constant.  */
12082   fmt_str = c_getstr (fmt);
12083   if (fmt_str == NULL)
12084     return;
12085
12086   if (!init_target_chars ())
12087     return;
12088
12089   /* If the format doesn't contain % args or %%, we know its size.  */
12090   if (strchr (fmt_str, target_percent) == 0)
12091     len = build_int_cstu (size_type_node, strlen (fmt_str));
12092   /* If the format is "%s" and first ... argument is a string literal,
12093      we know it too.  */
12094   else if (fcode == BUILT_IN_SPRINTF_CHK
12095            && strcmp (fmt_str, target_percent_s) == 0)
12096     {
12097       tree arg;
12098
12099       if (nargs < 5)
12100         return;
12101       arg = CALL_EXPR_ARG (exp, 4);
12102       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12103         return;
12104
12105       len = c_strlen (arg, 1);
12106       if (!len || ! host_integerp (len, 1))
12107         return;
12108     }
12109   else
12110     return;
12111
12112   if (! tree_int_cst_lt (len, size))
12113     warning_at (tree_nonartificial_location (exp),
12114                 0, "%Kcall to %D will always overflow destination buffer",
12115                 exp, get_callee_fndecl (exp));
12116 }
12117
12118 /* Emit warning if a free is called with address of a variable.  */
12119
12120 static void
12121 maybe_emit_free_warning (tree exp)
12122 {
12123   tree arg = CALL_EXPR_ARG (exp, 0);
12124
12125   STRIP_NOPS (arg);
12126   if (TREE_CODE (arg) != ADDR_EXPR)
12127     return;
12128
12129   arg = get_base_address (TREE_OPERAND (arg, 0));
12130   if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
12131     return;
12132
12133   if (SSA_VAR_P (arg))
12134     warning_at (tree_nonartificial_location (exp),
12135                 0, "%Kattempt to free a non-heap object %qD", exp, arg);
12136   else
12137     warning_at (tree_nonartificial_location (exp),
12138                 0, "%Kattempt to free a non-heap object", exp);
12139 }
12140
12141 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12142    if possible.  */
12143
12144 tree
12145 fold_builtin_object_size (tree ptr, tree ost)
12146 {
12147   unsigned HOST_WIDE_INT bytes;
12148   int object_size_type;
12149
12150   if (!validate_arg (ptr, POINTER_TYPE)
12151       || !validate_arg (ost, INTEGER_TYPE))
12152     return NULL_TREE;
12153
12154   STRIP_NOPS (ost);
12155
12156   if (TREE_CODE (ost) != INTEGER_CST
12157       || tree_int_cst_sgn (ost) < 0
12158       || compare_tree_int (ost, 3) > 0)
12159     return NULL_TREE;
12160
12161   object_size_type = tree_low_cst (ost, 0);
12162
12163   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12164      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12165      and (size_t) 0 for types 2 and 3.  */
12166   if (TREE_SIDE_EFFECTS (ptr))
12167     return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12168
12169   if (TREE_CODE (ptr) == ADDR_EXPR)
12170     {
12171       bytes = compute_builtin_object_size (ptr, object_size_type);
12172       if (double_int_fits_to_tree_p (size_type_node,
12173                                      uhwi_to_double_int (bytes)))
12174         return build_int_cstu (size_type_node, bytes);
12175     }
12176   else if (TREE_CODE (ptr) == SSA_NAME)
12177     {
12178       /* If object size is not known yet, delay folding until
12179        later.  Maybe subsequent passes will help determining
12180        it.  */
12181       bytes = compute_builtin_object_size (ptr, object_size_type);
12182       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
12183           && double_int_fits_to_tree_p (size_type_node,
12184                                         uhwi_to_double_int (bytes)))
12185         return build_int_cstu (size_type_node, bytes);
12186     }
12187
12188   return NULL_TREE;
12189 }
12190
12191 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12192    DEST, SRC, LEN, and SIZE are the arguments to the call.
12193    IGNORE is true, if return value can be ignored.  FCODE is the BUILT_IN_*
12194    code of the builtin.  If MAXLEN is not NULL, it is maximum length
12195    passed as third argument.  */
12196
12197 tree
12198 fold_builtin_memory_chk (location_t loc, tree fndecl,
12199                          tree dest, tree src, tree len, tree size,
12200                          tree maxlen, bool ignore,
12201                          enum built_in_function fcode)
12202 {
12203   tree fn;
12204
12205   if (!validate_arg (dest, POINTER_TYPE)
12206       || !validate_arg (src,
12207                         (fcode == BUILT_IN_MEMSET_CHK
12208                          ? INTEGER_TYPE : POINTER_TYPE))
12209       || !validate_arg (len, INTEGER_TYPE)
12210       || !validate_arg (size, INTEGER_TYPE))
12211     return NULL_TREE;
12212
12213   /* If SRC and DEST are the same (and not volatile), return DEST
12214      (resp. DEST+LEN for __mempcpy_chk).  */
12215   if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12216     {
12217       if (fcode != BUILT_IN_MEMPCPY_CHK)
12218         return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12219                                  dest, len);
12220       else
12221         {
12222           tree temp = fold_build2_loc (loc, POINTER_PLUS_EXPR, TREE_TYPE (dest),
12223                                    dest, len);
12224           return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12225         }
12226     }
12227
12228   if (! host_integerp (size, 1))
12229     return NULL_TREE;
12230
12231   if (! integer_all_onesp (size))
12232     {
12233       if (! host_integerp (len, 1))
12234         {
12235           /* If LEN is not constant, try MAXLEN too.
12236              For MAXLEN only allow optimizing into non-_ocs function
12237              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12238           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12239             {
12240               if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12241                 {
12242                   /* (void) __mempcpy_chk () can be optimized into
12243                      (void) __memcpy_chk ().  */
12244                   fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12245                   if (!fn)
12246                     return NULL_TREE;
12247
12248                   return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12249                 }
12250               return NULL_TREE;
12251             }
12252         }
12253       else
12254         maxlen = len;
12255
12256       if (tree_int_cst_lt (size, maxlen))
12257         return NULL_TREE;
12258     }
12259
12260   fn = NULL_TREE;
12261   /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12262      mem{cpy,pcpy,move,set} is available.  */
12263   switch (fcode)
12264     {
12265     case BUILT_IN_MEMCPY_CHK:
12266       fn = built_in_decls[BUILT_IN_MEMCPY];
12267       break;
12268     case BUILT_IN_MEMPCPY_CHK:
12269       fn = built_in_decls[BUILT_IN_MEMPCPY];
12270       break;
12271     case BUILT_IN_MEMMOVE_CHK:
12272       fn = built_in_decls[BUILT_IN_MEMMOVE];
12273       break;
12274     case BUILT_IN_MEMSET_CHK:
12275       fn = built_in_decls[BUILT_IN_MEMSET];
12276       break;
12277     default:
12278       break;
12279     }
12280
12281   if (!fn)
12282     return NULL_TREE;
12283
12284   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12285 }
12286
12287 /* Fold a call to the __st[rp]cpy_chk builtin.
12288    DEST, SRC, and SIZE are the arguments to the call.
12289    IGNORE is true if return value can be ignored.  FCODE is the BUILT_IN_*
12290    code of the builtin.  If MAXLEN is not NULL, it is maximum length of
12291    strings passed as second argument.  */
12292
12293 tree
12294 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12295                          tree src, tree size,
12296                          tree maxlen, bool ignore,
12297                          enum built_in_function fcode)
12298 {
12299   tree len, fn;
12300
12301   if (!validate_arg (dest, POINTER_TYPE)
12302       || !validate_arg (src, POINTER_TYPE)
12303       || !validate_arg (size, INTEGER_TYPE))
12304     return NULL_TREE;
12305
12306   /* If SRC and DEST are the same (and not volatile), return DEST.  */
12307   if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12308     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12309
12310   if (! host_integerp (size, 1))
12311     return NULL_TREE;
12312
12313   if (! integer_all_onesp (size))
12314     {
12315       len = c_strlen (src, 1);
12316       if (! len || ! 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_STPCPY_CHK)
12324                 {
12325                   if (! ignore)
12326                     return NULL_TREE;
12327
12328                   /* If return value of __stpcpy_chk is ignored,
12329                      optimize into __strcpy_chk.  */
12330                   fn = built_in_decls[BUILT_IN_STRCPY_CHK];
12331                   if (!fn)
12332                     return NULL_TREE;
12333
12334                   return build_call_expr_loc (loc, fn, 3, dest, src, size);
12335                 }
12336
12337               if (! len || TREE_SIDE_EFFECTS (len))
12338                 return NULL_TREE;
12339
12340               /* If c_strlen returned something, but not a constant,
12341                  transform __strcpy_chk into __memcpy_chk.  */
12342               fn = built_in_decls[BUILT_IN_MEMCPY_CHK];
12343               if (!fn)
12344                 return NULL_TREE;
12345
12346               len = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
12347               return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12348                                        build_call_expr_loc (loc, fn, 4,
12349                                                         dest, src, len, size));
12350             }
12351         }
12352       else
12353         maxlen = len;
12354
12355       if (! tree_int_cst_lt (maxlen, size))
12356         return NULL_TREE;
12357     }
12358
12359   /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available.  */
12360   fn = built_in_decls[fcode == BUILT_IN_STPCPY_CHK
12361                       ? BUILT_IN_STPCPY : BUILT_IN_STRCPY];
12362   if (!fn)
12363     return NULL_TREE;
12364
12365   return build_call_expr_loc (loc, fn, 2, dest, src);
12366 }
12367
12368 /* Fold a call to the __strncpy_chk builtin.  DEST, SRC, LEN, and SIZE
12369    are the arguments to the call.  If MAXLEN is not NULL, it is maximum
12370    length passed as third argument.  */
12371
12372 tree
12373 fold_builtin_strncpy_chk (location_t loc, tree dest, tree src,
12374                           tree len, tree size, tree maxlen)
12375 {
12376   tree fn;
12377
12378   if (!validate_arg (dest, POINTER_TYPE)
12379       || !validate_arg (src, POINTER_TYPE)
12380       || !validate_arg (len, INTEGER_TYPE)
12381       || !validate_arg (size, INTEGER_TYPE))
12382     return NULL_TREE;
12383
12384   if (! host_integerp (size, 1))
12385     return NULL_TREE;
12386
12387   if (! integer_all_onesp (size))
12388     {
12389       if (! host_integerp (len, 1))
12390         {
12391           /* If LEN is not constant, try MAXLEN too.
12392              For MAXLEN only allow optimizing into non-_ocs function
12393              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12394           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12395             return NULL_TREE;
12396         }
12397       else
12398         maxlen = len;
12399
12400       if (tree_int_cst_lt (size, maxlen))
12401         return NULL_TREE;
12402     }
12403
12404   /* If __builtin_strncpy_chk is used, assume strncpy is available.  */
12405   fn = built_in_decls[BUILT_IN_STRNCPY];
12406   if (!fn)
12407     return NULL_TREE;
12408
12409   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12410 }
12411
12412 /* Fold a call to the __strcat_chk builtin FNDECL.  DEST, SRC, and SIZE
12413    are the arguments to the call.  */
12414
12415 static tree
12416 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12417                          tree src, tree size)
12418 {
12419   tree fn;
12420   const char *p;
12421
12422   if (!validate_arg (dest, POINTER_TYPE)
12423       || !validate_arg (src, POINTER_TYPE)
12424       || !validate_arg (size, INTEGER_TYPE))
12425     return NULL_TREE;
12426
12427   p = c_getstr (src);
12428   /* If the SRC parameter is "", return DEST.  */
12429   if (p && *p == '\0')
12430     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12431
12432   if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12433     return NULL_TREE;
12434
12435   /* If __builtin_strcat_chk is used, assume strcat is available.  */
12436   fn = built_in_decls[BUILT_IN_STRCAT];
12437   if (!fn)
12438     return NULL_TREE;
12439
12440   return build_call_expr_loc (loc, fn, 2, dest, src);
12441 }
12442
12443 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12444    LEN, and SIZE.  */
12445
12446 static tree
12447 fold_builtin_strncat_chk (location_t loc, tree fndecl,
12448                           tree dest, tree src, tree len, tree size)
12449 {
12450   tree fn;
12451   const char *p;
12452
12453   if (!validate_arg (dest, POINTER_TYPE)
12454       || !validate_arg (src, POINTER_TYPE)
12455       || !validate_arg (size, INTEGER_TYPE)
12456       || !validate_arg (size, INTEGER_TYPE))
12457     return NULL_TREE;
12458
12459   p = c_getstr (src);
12460   /* If the SRC parameter is "" or if LEN is 0, return DEST.  */
12461   if (p && *p == '\0')
12462     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
12463   else if (integer_zerop (len))
12464     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12465
12466   if (! host_integerp (size, 1))
12467     return NULL_TREE;
12468
12469   if (! integer_all_onesp (size))
12470     {
12471       tree src_len = c_strlen (src, 1);
12472       if (src_len
12473           && host_integerp (src_len, 1)
12474           && host_integerp (len, 1)
12475           && ! tree_int_cst_lt (len, src_len))
12476         {
12477           /* If LEN >= strlen (SRC), optimize into __strcat_chk.  */
12478           fn = built_in_decls[BUILT_IN_STRCAT_CHK];
12479           if (!fn)
12480             return NULL_TREE;
12481
12482           return build_call_expr_loc (loc, fn, 3, dest, src, size);
12483         }
12484       return NULL_TREE;
12485     }
12486
12487   /* If __builtin_strncat_chk is used, assume strncat is available.  */
12488   fn = built_in_decls[BUILT_IN_STRNCAT];
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 EXP to __{,v}sprintf_chk having NARGS passed as ARGS.
12496    Return NULL_TREE if a normal call should be emitted rather than
12497    expanding the function inline.  FCODE is either BUILT_IN_SPRINTF_CHK
12498    or BUILT_IN_VSPRINTF_CHK.  */
12499
12500 static tree
12501 fold_builtin_sprintf_chk_1 (location_t loc, int nargs, tree *args,
12502                             enum built_in_function fcode)
12503 {
12504   tree dest, size, len, fn, fmt, flag;
12505   const char *fmt_str;
12506
12507   /* Verify the required arguments in the original call.  */
12508   if (nargs < 4)
12509     return NULL_TREE;
12510   dest = args[0];
12511   if (!validate_arg (dest, POINTER_TYPE))
12512     return NULL_TREE;
12513   flag = args[1];
12514   if (!validate_arg (flag, INTEGER_TYPE))
12515     return NULL_TREE;
12516   size = args[2];
12517   if (!validate_arg (size, INTEGER_TYPE))
12518     return NULL_TREE;
12519   fmt = args[3];
12520   if (!validate_arg (fmt, POINTER_TYPE))
12521     return NULL_TREE;
12522
12523   if (! host_integerp (size, 1))
12524     return NULL_TREE;
12525
12526   len = NULL_TREE;
12527
12528   if (!init_target_chars ())
12529     return NULL_TREE;
12530
12531   /* Check whether the format is a literal string constant.  */
12532   fmt_str = c_getstr (fmt);
12533   if (fmt_str != NULL)
12534     {
12535       /* If the format doesn't contain % args or %%, we know the size.  */
12536       if (strchr (fmt_str, target_percent) == 0)
12537         {
12538           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
12539             len = build_int_cstu (size_type_node, strlen (fmt_str));
12540         }
12541       /* If the format is "%s" and first ... argument is a string literal,
12542          we know the size too.  */
12543       else if (fcode == BUILT_IN_SPRINTF_CHK
12544                && strcmp (fmt_str, target_percent_s) == 0)
12545         {
12546           tree arg;
12547
12548           if (nargs == 5)
12549             {
12550               arg = args[4];
12551               if (validate_arg (arg, POINTER_TYPE))
12552                 {
12553                   len = c_strlen (arg, 1);
12554                   if (! len || ! host_integerp (len, 1))
12555                     len = NULL_TREE;
12556                 }
12557             }
12558         }
12559     }
12560
12561   if (! integer_all_onesp (size))
12562     {
12563       if (! len || ! tree_int_cst_lt (len, size))
12564         return NULL_TREE;
12565     }
12566
12567   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
12568      or if format doesn't contain % chars or is "%s".  */
12569   if (! integer_zerop (flag))
12570     {
12571       if (fmt_str == NULL)
12572         return NULL_TREE;
12573       if (strchr (fmt_str, target_percent) != NULL
12574           && strcmp (fmt_str, target_percent_s))
12575         return NULL_TREE;
12576     }
12577
12578   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
12579   fn = built_in_decls[fcode == BUILT_IN_VSPRINTF_CHK
12580                       ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF];
12581   if (!fn)
12582     return NULL_TREE;
12583
12584   return rewrite_call_expr_array (loc, nargs, args, 4, fn, 2, dest, fmt);
12585 }
12586
12587 /* Fold a call EXP to __{,v}sprintf_chk.  Return NULL_TREE if
12588    a normal call should be emitted rather than expanding the function
12589    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
12590
12591 static tree
12592 fold_builtin_sprintf_chk (location_t loc, tree exp,
12593                           enum built_in_function fcode)
12594 {
12595   return fold_builtin_sprintf_chk_1 (loc, call_expr_nargs (exp),
12596                                      CALL_EXPR_ARGP (exp), fcode);
12597 }
12598
12599 /* Fold a call EXP to {,v}snprintf having NARGS passed as ARGS.  Return
12600    NULL_TREE if a normal call should be emitted rather than expanding
12601    the function inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
12602    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
12603    passed as second argument.  */
12604
12605 static tree
12606 fold_builtin_snprintf_chk_1 (location_t loc, int nargs, tree *args,
12607                              tree maxlen, enum built_in_function fcode)
12608 {
12609   tree dest, size, len, fn, fmt, flag;
12610   const char *fmt_str;
12611
12612   /* Verify the required arguments in the original call.  */
12613   if (nargs < 5)
12614     return NULL_TREE;
12615   dest = args[0];
12616   if (!validate_arg (dest, POINTER_TYPE))
12617     return NULL_TREE;
12618   len = args[1];
12619   if (!validate_arg (len, INTEGER_TYPE))
12620     return NULL_TREE;
12621   flag = args[2];
12622   if (!validate_arg (flag, INTEGER_TYPE))
12623     return NULL_TREE;
12624   size = args[3];
12625   if (!validate_arg (size, INTEGER_TYPE))
12626     return NULL_TREE;
12627   fmt = args[4];
12628   if (!validate_arg (fmt, POINTER_TYPE))
12629     return NULL_TREE;
12630
12631   if (! host_integerp (size, 1))
12632     return NULL_TREE;
12633
12634   if (! integer_all_onesp (size))
12635     {
12636       if (! host_integerp (len, 1))
12637         {
12638           /* If LEN is not constant, try MAXLEN too.
12639              For MAXLEN only allow optimizing into non-_ocs function
12640              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12641           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12642             return NULL_TREE;
12643         }
12644       else
12645         maxlen = len;
12646
12647       if (tree_int_cst_lt (size, maxlen))
12648         return NULL_TREE;
12649     }
12650
12651   if (!init_target_chars ())
12652     return NULL_TREE;
12653
12654   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
12655      or if format doesn't contain % chars or is "%s".  */
12656   if (! integer_zerop (flag))
12657     {
12658       fmt_str = c_getstr (fmt);
12659       if (fmt_str == NULL)
12660         return NULL_TREE;
12661       if (strchr (fmt_str, target_percent) != NULL
12662           && strcmp (fmt_str, target_percent_s))
12663         return NULL_TREE;
12664     }
12665
12666   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
12667      available.  */
12668   fn = built_in_decls[fcode == BUILT_IN_VSNPRINTF_CHK
12669                       ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF];
12670   if (!fn)
12671     return NULL_TREE;
12672
12673   return rewrite_call_expr_array (loc, nargs, args, 5, fn, 3, dest, len, fmt);
12674 }
12675
12676 /* Fold a call EXP to {,v}snprintf.  Return NULL_TREE if
12677    a normal call should be emitted rather than expanding the function
12678    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
12679    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
12680    passed as second argument.  */
12681
12682 tree
12683 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
12684                            enum built_in_function fcode)
12685 {
12686   return fold_builtin_snprintf_chk_1 (loc, call_expr_nargs (exp),
12687                                       CALL_EXPR_ARGP (exp), maxlen, fcode);
12688 }
12689
12690 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
12691    FMT and ARG are the arguments to the call; we don't fold cases with
12692    more than 2 arguments, and ARG may be null if this is a 1-argument case.
12693
12694    Return NULL_TREE if no simplification was possible, otherwise return the
12695    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12696    code of the function to be simplified.  */
12697
12698 static tree
12699 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
12700                      tree arg, bool ignore,
12701                      enum built_in_function fcode)
12702 {
12703   tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
12704   const char *fmt_str = NULL;
12705
12706   /* If the return value is used, don't do the transformation.  */
12707   if (! ignore)
12708     return NULL_TREE;
12709
12710   /* Verify the required arguments in the original call.  */
12711   if (!validate_arg (fmt, POINTER_TYPE))
12712     return NULL_TREE;
12713
12714   /* Check whether the format is a literal string constant.  */
12715   fmt_str = c_getstr (fmt);
12716   if (fmt_str == NULL)
12717     return NULL_TREE;
12718
12719   if (fcode == BUILT_IN_PRINTF_UNLOCKED)
12720     {
12721       /* If we're using an unlocked function, assume the other
12722          unlocked functions exist explicitly.  */
12723       fn_putchar = built_in_decls[BUILT_IN_PUTCHAR_UNLOCKED];
12724       fn_puts = built_in_decls[BUILT_IN_PUTS_UNLOCKED];
12725     }
12726   else
12727     {
12728       fn_putchar = implicit_built_in_decls[BUILT_IN_PUTCHAR];
12729       fn_puts = implicit_built_in_decls[BUILT_IN_PUTS];
12730     }
12731
12732   if (!init_target_chars ())
12733     return NULL_TREE;
12734
12735   if (strcmp (fmt_str, target_percent_s) == 0
12736       || strchr (fmt_str, target_percent) == NULL)
12737     {
12738       const char *str;
12739
12740       if (strcmp (fmt_str, target_percent_s) == 0)
12741         {
12742           if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12743             return NULL_TREE;
12744
12745           if (!arg || !validate_arg (arg, POINTER_TYPE))
12746             return NULL_TREE;
12747
12748           str = c_getstr (arg);
12749           if (str == NULL)
12750             return NULL_TREE;
12751         }
12752       else
12753         {
12754           /* The format specifier doesn't contain any '%' characters.  */
12755           if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
12756               && arg)
12757             return NULL_TREE;
12758           str = fmt_str;
12759         }
12760
12761       /* If the string was "", printf does nothing.  */
12762       if (str[0] == '\0')
12763         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12764
12765       /* If the string has length of 1, call putchar.  */
12766       if (str[1] == '\0')
12767         {
12768           /* Given printf("c"), (where c is any one character,)
12769              convert "c"[0] to an int and pass that to the replacement
12770              function.  */
12771           newarg = build_int_cst (NULL_TREE, str[0]);
12772           if (fn_putchar)
12773             call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
12774         }
12775       else
12776         {
12777           /* If the string was "string\n", call puts("string").  */
12778           size_t len = strlen (str);
12779           if ((unsigned char)str[len - 1] == target_newline)
12780             {
12781               /* Create a NUL-terminated string that's one char shorter
12782                  than the original, stripping off the trailing '\n'.  */
12783               char *newstr = XALLOCAVEC (char, len);
12784               memcpy (newstr, str, len - 1);
12785               newstr[len - 1] = 0;
12786
12787               newarg = build_string_literal (len, newstr);
12788               if (fn_puts)
12789                 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
12790             }
12791           else
12792             /* We'd like to arrange to call fputs(string,stdout) here,
12793                but we need stdout and don't have a way to get it yet.  */
12794             return NULL_TREE;
12795         }
12796     }
12797
12798   /* The other optimizations can be done only on the non-va_list variants.  */
12799   else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
12800     return NULL_TREE;
12801
12802   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
12803   else if (strcmp (fmt_str, target_percent_s_newline) == 0)
12804     {
12805       if (!arg || !validate_arg (arg, POINTER_TYPE))
12806         return NULL_TREE;
12807       if (fn_puts)
12808         call = build_call_expr_loc (loc, fn_puts, 1, arg);
12809     }
12810
12811   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
12812   else if (strcmp (fmt_str, target_percent_c) == 0)
12813     {
12814       if (!arg || !validate_arg (arg, INTEGER_TYPE))
12815         return NULL_TREE;
12816       if (fn_putchar)
12817         call = build_call_expr_loc (loc, fn_putchar, 1, arg);
12818     }
12819
12820   if (!call)
12821     return NULL_TREE;
12822
12823   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12824 }
12825
12826 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
12827    FP, FMT, and ARG are the arguments to the call.  We don't fold calls with
12828    more than 3 arguments, and ARG may be null in the 2-argument case.
12829
12830    Return NULL_TREE if no simplification was possible, otherwise return the
12831    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
12832    code of the function to be simplified.  */
12833
12834 static tree
12835 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
12836                       tree fmt, tree arg, bool ignore,
12837                       enum built_in_function fcode)
12838 {
12839   tree fn_fputc, fn_fputs, call = NULL_TREE;
12840   const char *fmt_str = NULL;
12841
12842   /* If the return value is used, don't do the transformation.  */
12843   if (! ignore)
12844     return NULL_TREE;
12845
12846   /* Verify the required arguments in the original call.  */
12847   if (!validate_arg (fp, POINTER_TYPE))
12848     return NULL_TREE;
12849   if (!validate_arg (fmt, POINTER_TYPE))
12850     return NULL_TREE;
12851
12852   /* Check whether the format is a literal string constant.  */
12853   fmt_str = c_getstr (fmt);
12854   if (fmt_str == NULL)
12855     return NULL_TREE;
12856
12857   if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
12858     {
12859       /* If we're using an unlocked function, assume the other
12860          unlocked functions exist explicitly.  */
12861       fn_fputc = built_in_decls[BUILT_IN_FPUTC_UNLOCKED];
12862       fn_fputs = built_in_decls[BUILT_IN_FPUTS_UNLOCKED];
12863     }
12864   else
12865     {
12866       fn_fputc = implicit_built_in_decls[BUILT_IN_FPUTC];
12867       fn_fputs = implicit_built_in_decls[BUILT_IN_FPUTS];
12868     }
12869
12870   if (!init_target_chars ())
12871     return NULL_TREE;
12872
12873   /* If the format doesn't contain % args or %%, use strcpy.  */
12874   if (strchr (fmt_str, target_percent) == NULL)
12875     {
12876       if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
12877           && arg)
12878         return NULL_TREE;
12879
12880       /* If the format specifier was "", fprintf does nothing.  */
12881       if (fmt_str[0] == '\0')
12882         {
12883           /* If FP has side-effects, just wait until gimplification is
12884              done.  */
12885           if (TREE_SIDE_EFFECTS (fp))
12886             return NULL_TREE;
12887
12888           return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
12889         }
12890
12891       /* When "string" doesn't contain %, replace all cases of
12892          fprintf (fp, string) with fputs (string, fp).  The fputs
12893          builtin will take care of special cases like length == 1.  */
12894       if (fn_fputs)
12895         call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
12896     }
12897
12898   /* The other optimizations can be done only on the non-va_list variants.  */
12899   else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
12900     return NULL_TREE;
12901
12902   /* If the format specifier was "%s", call __builtin_fputs (arg, fp).  */
12903   else if (strcmp (fmt_str, target_percent_s) == 0)
12904     {
12905       if (!arg || !validate_arg (arg, POINTER_TYPE))
12906         return NULL_TREE;
12907       if (fn_fputs)
12908         call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
12909     }
12910
12911   /* If the format specifier was "%c", call __builtin_fputc (arg, fp).  */
12912   else if (strcmp (fmt_str, target_percent_c) == 0)
12913     {
12914       if (!arg || !validate_arg (arg, INTEGER_TYPE))
12915         return NULL_TREE;
12916       if (fn_fputc)
12917         call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
12918     }
12919
12920   if (!call)
12921     return NULL_TREE;
12922   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
12923 }
12924
12925 /* Initialize format string characters in the target charset.  */
12926
12927 static bool
12928 init_target_chars (void)
12929 {
12930   static bool init;
12931   if (!init)
12932     {
12933       target_newline = lang_hooks.to_target_charset ('\n');
12934       target_percent = lang_hooks.to_target_charset ('%');
12935       target_c = lang_hooks.to_target_charset ('c');
12936       target_s = lang_hooks.to_target_charset ('s');
12937       if (target_newline == 0 || target_percent == 0 || target_c == 0
12938           || target_s == 0)
12939         return false;
12940
12941       target_percent_c[0] = target_percent;
12942       target_percent_c[1] = target_c;
12943       target_percent_c[2] = '\0';
12944
12945       target_percent_s[0] = target_percent;
12946       target_percent_s[1] = target_s;
12947       target_percent_s[2] = '\0';
12948
12949       target_percent_s_newline[0] = target_percent;
12950       target_percent_s_newline[1] = target_s;
12951       target_percent_s_newline[2] = target_newline;
12952       target_percent_s_newline[3] = '\0';
12953
12954       init = true;
12955     }
12956   return true;
12957 }
12958
12959 /* Helper function for do_mpfr_arg*().  Ensure M is a normal number
12960    and no overflow/underflow occurred.  INEXACT is true if M was not
12961    exactly calculated.  TYPE is the tree type for the result.  This
12962    function assumes that you cleared the MPFR flags and then
12963    calculated M to see if anything subsequently set a flag prior to
12964    entering this function.  Return NULL_TREE if any checks fail.  */
12965
12966 static tree
12967 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
12968 {
12969   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
12970      overflow/underflow occurred.  If -frounding-math, proceed iff the
12971      result of calling FUNC was exact.  */
12972   if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
12973       && (!flag_rounding_math || !inexact))
12974     {
12975       REAL_VALUE_TYPE rr;
12976
12977       real_from_mpfr (&rr, m, type, GMP_RNDN);
12978       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
12979          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
12980          but the mpft_t is not, then we underflowed in the
12981          conversion.  */
12982       if (real_isfinite (&rr)
12983           && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
12984         {
12985           REAL_VALUE_TYPE rmode;
12986
12987           real_convert (&rmode, TYPE_MODE (type), &rr);
12988           /* Proceed iff the specified mode can hold the value.  */
12989           if (real_identical (&rmode, &rr))
12990             return build_real (type, rmode);
12991         }
12992     }
12993   return NULL_TREE;
12994 }
12995
12996 /* Helper function for do_mpc_arg*().  Ensure M is a normal complex
12997    number and no overflow/underflow occurred.  INEXACT is true if M
12998    was not exactly calculated.  TYPE is the tree type for the result.
12999    This function assumes that you cleared the MPFR flags and then
13000    calculated M to see if anything subsequently set a flag prior to
13001    entering this function.  Return NULL_TREE if any checks fail, if
13002    FORCE_CONVERT is true, then bypass the checks.  */
13003
13004 static tree
13005 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
13006 {
13007   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13008      overflow/underflow occurred.  If -frounding-math, proceed iff the
13009      result of calling FUNC was exact.  */
13010   if (force_convert
13011       || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
13012           && !mpfr_overflow_p () && !mpfr_underflow_p ()
13013           && (!flag_rounding_math || !inexact)))
13014     {
13015       REAL_VALUE_TYPE re, im;
13016
13017       real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
13018       real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
13019       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
13020          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
13021          but the mpft_t is not, then we underflowed in the
13022          conversion.  */
13023       if (force_convert
13024           || (real_isfinite (&re) && real_isfinite (&im)
13025               && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
13026               && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
13027         {
13028           REAL_VALUE_TYPE re_mode, im_mode;
13029
13030           real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
13031           real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
13032           /* Proceed iff the specified mode can hold the value.  */
13033           if (force_convert
13034               || (real_identical (&re_mode, &re)
13035                   && real_identical (&im_mode, &im)))
13036             return build_complex (type, build_real (TREE_TYPE (type), re_mode),
13037                                   build_real (TREE_TYPE (type), im_mode));
13038         }
13039     }
13040   return NULL_TREE;
13041 }
13042
13043 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
13044    FUNC on it and return the resulting value as a tree with type TYPE.
13045    If MIN and/or MAX are not NULL, then the supplied ARG must be
13046    within those bounds.  If INCLUSIVE is true, then MIN/MAX are
13047    acceptable values, otherwise they are not.  The mpfr precision is
13048    set to the precision of TYPE.  We assume that function FUNC returns
13049    zero if the result could be calculated exactly within the requested
13050    precision.  */
13051
13052 static tree
13053 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
13054               const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
13055               bool inclusive)
13056 {
13057   tree result = NULL_TREE;
13058
13059   STRIP_NOPS (arg);
13060
13061   /* To proceed, MPFR must exactly represent the target floating point
13062      format, which only happens when the target base equals two.  */
13063   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13064       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13065     {
13066       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13067
13068       if (real_isfinite (ra)
13069           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13070           && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13071         {
13072           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13073           const int prec = fmt->p;
13074           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13075           int inexact;
13076           mpfr_t m;
13077
13078           mpfr_init2 (m, prec);
13079           mpfr_from_real (m, ra, GMP_RNDN);
13080           mpfr_clear_flags ();
13081           inexact = func (m, m, rnd);
13082           result = do_mpfr_ckconv (m, type, inexact);
13083           mpfr_clear (m);
13084         }
13085     }
13086
13087   return result;
13088 }
13089
13090 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13091    FUNC on it and return the resulting value as a tree with type TYPE.
13092    The mpfr precision is set to the precision of TYPE.  We assume that
13093    function FUNC returns zero if the result could be calculated
13094    exactly within the requested precision.  */
13095
13096 static tree
13097 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13098               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13099 {
13100   tree result = NULL_TREE;
13101
13102   STRIP_NOPS (arg1);
13103   STRIP_NOPS (arg2);
13104
13105   /* To proceed, MPFR must exactly represent the target floating point
13106      format, which only happens when the target base equals two.  */
13107   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13108       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13109       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13110     {
13111       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13112       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13113
13114       if (real_isfinite (ra1) && real_isfinite (ra2))
13115         {
13116           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13117           const int prec = fmt->p;
13118           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13119           int inexact;
13120           mpfr_t m1, m2;
13121
13122           mpfr_inits2 (prec, m1, m2, NULL);
13123           mpfr_from_real (m1, ra1, GMP_RNDN);
13124           mpfr_from_real (m2, ra2, GMP_RNDN);
13125           mpfr_clear_flags ();
13126           inexact = func (m1, m1, m2, rnd);
13127           result = do_mpfr_ckconv (m1, type, inexact);
13128           mpfr_clears (m1, m2, NULL);
13129         }
13130     }
13131
13132   return result;
13133 }
13134
13135 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13136    FUNC on it and return the resulting value as a tree with type TYPE.
13137    The mpfr precision is set to the precision of TYPE.  We assume that
13138    function FUNC returns zero if the result could be calculated
13139    exactly within the requested precision.  */
13140
13141 static tree
13142 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13143               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13144 {
13145   tree result = NULL_TREE;
13146
13147   STRIP_NOPS (arg1);
13148   STRIP_NOPS (arg2);
13149   STRIP_NOPS (arg3);
13150
13151   /* To proceed, MPFR must exactly represent the target floating point
13152      format, which only happens when the target base equals two.  */
13153   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13154       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13155       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13156       && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13157     {
13158       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13159       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13160       const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13161
13162       if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13163         {
13164           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13165           const int prec = fmt->p;
13166           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13167           int inexact;
13168           mpfr_t m1, m2, m3;
13169
13170           mpfr_inits2 (prec, m1, m2, m3, NULL);
13171           mpfr_from_real (m1, ra1, GMP_RNDN);
13172           mpfr_from_real (m2, ra2, GMP_RNDN);
13173           mpfr_from_real (m3, ra3, GMP_RNDN);
13174           mpfr_clear_flags ();
13175           inexact = func (m1, m1, m2, m3, rnd);
13176           result = do_mpfr_ckconv (m1, type, inexact);
13177           mpfr_clears (m1, m2, m3, NULL);
13178         }
13179     }
13180
13181   return result;
13182 }
13183
13184 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13185    the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13186    If ARG_SINP and ARG_COSP are NULL then the result is returned
13187    as a complex value.
13188    The type is taken from the type of ARG and is used for setting the
13189    precision of the calculation and results.  */
13190
13191 static tree
13192 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13193 {
13194   tree const type = TREE_TYPE (arg);
13195   tree result = NULL_TREE;
13196
13197   STRIP_NOPS (arg);
13198
13199   /* To proceed, MPFR must exactly represent the target floating point
13200      format, which only happens when the target base equals two.  */
13201   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13202       && TREE_CODE (arg) == REAL_CST
13203       && !TREE_OVERFLOW (arg))
13204     {
13205       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13206
13207       if (real_isfinite (ra))
13208         {
13209           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13210           const int prec = fmt->p;
13211           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13212           tree result_s, result_c;
13213           int inexact;
13214           mpfr_t m, ms, mc;
13215
13216           mpfr_inits2 (prec, m, ms, mc, NULL);
13217           mpfr_from_real (m, ra, GMP_RNDN);
13218           mpfr_clear_flags ();
13219           inexact = mpfr_sin_cos (ms, mc, m, rnd);
13220           result_s = do_mpfr_ckconv (ms, type, inexact);
13221           result_c = do_mpfr_ckconv (mc, type, inexact);
13222           mpfr_clears (m, ms, mc, NULL);
13223           if (result_s && result_c)
13224             {
13225               /* If we are to return in a complex value do so.  */
13226               if (!arg_sinp && !arg_cosp)
13227                 return build_complex (build_complex_type (type),
13228                                       result_c, result_s);
13229
13230               /* Dereference the sin/cos pointer arguments.  */
13231               arg_sinp = build_fold_indirect_ref (arg_sinp);
13232               arg_cosp = build_fold_indirect_ref (arg_cosp);
13233               /* Proceed if valid pointer type were passed in.  */
13234               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13235                   && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13236                 {
13237                   /* Set the values. */
13238                   result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13239                                           result_s);
13240                   TREE_SIDE_EFFECTS (result_s) = 1;
13241                   result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13242                                           result_c);
13243                   TREE_SIDE_EFFECTS (result_c) = 1;
13244                   /* Combine the assignments into a compound expr.  */
13245                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13246                                                     result_s, result_c));
13247                 }
13248             }
13249         }
13250     }
13251   return result;
13252 }
13253
13254 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13255    two-argument mpfr order N Bessel function FUNC on them and return
13256    the resulting value as a tree with type TYPE.  The mpfr precision
13257    is set to the precision of TYPE.  We assume that function FUNC
13258    returns zero if the result could be calculated exactly within the
13259    requested precision.  */
13260 static tree
13261 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13262                   int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13263                   const REAL_VALUE_TYPE *min, bool inclusive)
13264 {
13265   tree result = NULL_TREE;
13266
13267   STRIP_NOPS (arg1);
13268   STRIP_NOPS (arg2);
13269
13270   /* To proceed, MPFR must exactly represent the target floating point
13271      format, which only happens when the target base equals two.  */
13272   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13273       && host_integerp (arg1, 0)
13274       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13275     {
13276       const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13277       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13278
13279       if (n == (long)n
13280           && real_isfinite (ra)
13281           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13282         {
13283           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13284           const int prec = fmt->p;
13285           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13286           int inexact;
13287           mpfr_t m;
13288
13289           mpfr_init2 (m, prec);
13290           mpfr_from_real (m, ra, GMP_RNDN);
13291           mpfr_clear_flags ();
13292           inexact = func (m, n, m, rnd);
13293           result = do_mpfr_ckconv (m, type, inexact);
13294           mpfr_clear (m);
13295         }
13296     }
13297
13298   return result;
13299 }
13300
13301 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13302    the pointer *(ARG_QUO) and return the result.  The type is taken
13303    from the type of ARG0 and is used for setting the precision of the
13304    calculation and results.  */
13305
13306 static tree
13307 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13308 {
13309   tree const type = TREE_TYPE (arg0);
13310   tree result = NULL_TREE;
13311
13312   STRIP_NOPS (arg0);
13313   STRIP_NOPS (arg1);
13314
13315   /* To proceed, MPFR must exactly represent the target floating point
13316      format, which only happens when the target base equals two.  */
13317   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13318       && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13319       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13320     {
13321       const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13322       const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13323
13324       if (real_isfinite (ra0) && real_isfinite (ra1))
13325         {
13326           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13327           const int prec = fmt->p;
13328           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13329           tree result_rem;
13330           long integer_quo;
13331           mpfr_t m0, m1;
13332
13333           mpfr_inits2 (prec, m0, m1, NULL);
13334           mpfr_from_real (m0, ra0, GMP_RNDN);
13335           mpfr_from_real (m1, ra1, GMP_RNDN);
13336           mpfr_clear_flags ();
13337           mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13338           /* Remquo is independent of the rounding mode, so pass
13339              inexact=0 to do_mpfr_ckconv().  */
13340           result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13341           mpfr_clears (m0, m1, NULL);
13342           if (result_rem)
13343             {
13344               /* MPFR calculates quo in the host's long so it may
13345                  return more bits in quo than the target int can hold
13346                  if sizeof(host long) > sizeof(target int).  This can
13347                  happen even for native compilers in LP64 mode.  In
13348                  these cases, modulo the quo value with the largest
13349                  number that the target int can hold while leaving one
13350                  bit for the sign.  */
13351               if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13352                 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13353
13354               /* Dereference the quo pointer argument.  */
13355               arg_quo = build_fold_indirect_ref (arg_quo);
13356               /* Proceed iff a valid pointer type was passed in.  */
13357               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13358                 {
13359                   /* Set the value. */
13360                   tree result_quo = fold_build2 (MODIFY_EXPR,
13361                                                  TREE_TYPE (arg_quo), arg_quo,
13362                                                  build_int_cst (NULL, integer_quo));
13363                   TREE_SIDE_EFFECTS (result_quo) = 1;
13364                   /* Combine the quo assignment with the rem.  */
13365                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13366                                                     result_quo, result_rem));
13367                 }
13368             }
13369         }
13370     }
13371   return result;
13372 }
13373
13374 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13375    resulting value as a tree with type TYPE.  The mpfr precision is
13376    set to the precision of TYPE.  We assume that this mpfr function
13377    returns zero if the result could be calculated exactly within the
13378    requested precision.  In addition, the integer pointer represented
13379    by ARG_SG will be dereferenced and set to the appropriate signgam
13380    (-1,1) value.  */
13381
13382 static tree
13383 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13384 {
13385   tree result = NULL_TREE;
13386
13387   STRIP_NOPS (arg);
13388
13389   /* To proceed, MPFR must exactly represent the target floating point
13390      format, which only happens when the target base equals two.  Also
13391      verify ARG is a constant and that ARG_SG is an int pointer.  */
13392   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13393       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13394       && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13395       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13396     {
13397       const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13398
13399       /* In addition to NaN and Inf, the argument cannot be zero or a
13400          negative integer.  */
13401       if (real_isfinite (ra)
13402           && ra->cl != rvc_zero
13403           && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13404         {
13405           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13406           const int prec = fmt->p;
13407           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13408           int inexact, sg;
13409           mpfr_t m;
13410           tree result_lg;
13411
13412           mpfr_init2 (m, prec);
13413           mpfr_from_real (m, ra, GMP_RNDN);
13414           mpfr_clear_flags ();
13415           inexact = mpfr_lgamma (m, &sg, m, rnd);
13416           result_lg = do_mpfr_ckconv (m, type, inexact);
13417           mpfr_clear (m);
13418           if (result_lg)
13419             {
13420               tree result_sg;
13421
13422               /* Dereference the arg_sg pointer argument.  */
13423               arg_sg = build_fold_indirect_ref (arg_sg);
13424               /* Assign the signgam value into *arg_sg. */
13425               result_sg = fold_build2 (MODIFY_EXPR,
13426                                        TREE_TYPE (arg_sg), arg_sg,
13427                                        build_int_cst (NULL, sg));
13428               TREE_SIDE_EFFECTS (result_sg) = 1;
13429               /* Combine the signgam assignment with the lgamma result.  */
13430               result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13431                                                 result_sg, result_lg));
13432             }
13433         }
13434     }
13435
13436   return result;
13437 }
13438
13439 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13440    function FUNC on it and return the resulting value as a tree with
13441    type TYPE.  The mpfr precision is set to the precision of TYPE.  We
13442    assume that function FUNC returns zero if the result could be
13443    calculated exactly within the requested precision.  */
13444
13445 static tree
13446 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13447 {
13448   tree result = NULL_TREE;
13449
13450   STRIP_NOPS (arg);
13451
13452   /* To proceed, MPFR must exactly represent the target floating point
13453      format, which only happens when the target base equals two.  */
13454   if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
13455       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
13456       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
13457     {
13458       const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
13459       const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
13460
13461       if (real_isfinite (re) && real_isfinite (im))
13462         {
13463           const struct real_format *const fmt =
13464             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13465           const int prec = fmt->p;
13466           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13467           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13468           int inexact;
13469           mpc_t m;
13470
13471           mpc_init2 (m, prec);
13472           mpfr_from_real (mpc_realref(m), re, rnd);
13473           mpfr_from_real (mpc_imagref(m), im, rnd);
13474           mpfr_clear_flags ();
13475           inexact = func (m, m, crnd);
13476           result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
13477           mpc_clear (m);
13478         }
13479     }
13480
13481   return result;
13482 }
13483
13484 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
13485    mpc function FUNC on it and return the resulting value as a tree
13486    with type TYPE.  The mpfr precision is set to the precision of
13487    TYPE.  We assume that function FUNC returns zero if the result
13488    could be calculated exactly within the requested precision.  If
13489    DO_NONFINITE is true, then fold expressions containing Inf or NaN
13490    in the arguments and/or results.  */
13491
13492 tree
13493 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
13494              int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
13495 {
13496   tree result = NULL_TREE;
13497
13498   STRIP_NOPS (arg0);
13499   STRIP_NOPS (arg1);
13500
13501   /* To proceed, MPFR must exactly represent the target floating point
13502      format, which only happens when the target base equals two.  */
13503   if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
13504       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
13505       && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
13506       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
13507       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
13508     {
13509       const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
13510       const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
13511       const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
13512       const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
13513
13514       if (do_nonfinite
13515           || (real_isfinite (re0) && real_isfinite (im0)
13516               && real_isfinite (re1) && real_isfinite (im1)))
13517         {
13518           const struct real_format *const fmt =
13519             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
13520           const int prec = fmt->p;
13521           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
13522           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
13523           int inexact;
13524           mpc_t m0, m1;
13525
13526           mpc_init2 (m0, prec);
13527           mpc_init2 (m1, prec);
13528           mpfr_from_real (mpc_realref(m0), re0, rnd);
13529           mpfr_from_real (mpc_imagref(m0), im0, rnd);
13530           mpfr_from_real (mpc_realref(m1), re1, rnd);
13531           mpfr_from_real (mpc_imagref(m1), im1, rnd);
13532           mpfr_clear_flags ();
13533           inexact = func (m0, m0, m1, crnd);
13534           result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
13535           mpc_clear (m0);
13536           mpc_clear (m1);
13537         }
13538     }
13539
13540   return result;
13541 }
13542
13543 /* Fold a call STMT to __{,v}sprintf_chk.  Return NULL_TREE if
13544    a normal call should be emitted rather than expanding the function
13545    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
13546
13547 static tree
13548 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
13549 {
13550   int nargs = gimple_call_num_args (stmt);
13551
13552   return fold_builtin_sprintf_chk_1 (gimple_location (stmt), nargs,
13553                                      (nargs > 0
13554                                       ? gimple_call_arg_ptr (stmt, 0)
13555                                       : &error_mark_node), fcode);
13556 }
13557
13558 /* Fold a call STMT to {,v}snprintf.  Return NULL_TREE if
13559    a normal call should be emitted rather than expanding the function
13560    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
13561    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
13562    passed as second argument.  */
13563
13564 tree
13565 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
13566                                   enum built_in_function fcode)
13567 {
13568   int nargs = gimple_call_num_args (stmt);
13569
13570   return fold_builtin_snprintf_chk_1 (gimple_location (stmt), nargs,
13571                                       (nargs > 0
13572                                        ? gimple_call_arg_ptr (stmt, 0)
13573                                        : &error_mark_node), maxlen, fcode);
13574 }
13575
13576 /* Builtins with folding operations that operate on "..." arguments
13577    need special handling; we need to store the arguments in a convenient
13578    data structure before attempting any folding.  Fortunately there are
13579    only a few builtins that fall into this category.  FNDECL is the
13580    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
13581    result of the function call is ignored.  */
13582
13583 static tree
13584 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
13585                              bool ignore ATTRIBUTE_UNUSED)
13586 {
13587   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
13588   tree ret = NULL_TREE;
13589
13590   switch (fcode)
13591     {
13592     case BUILT_IN_SPRINTF_CHK:
13593     case BUILT_IN_VSPRINTF_CHK:
13594       ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
13595       break;
13596
13597     case BUILT_IN_SNPRINTF_CHK:
13598     case BUILT_IN_VSNPRINTF_CHK:
13599       ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
13600
13601     default:
13602       break;
13603     }
13604   if (ret)
13605     {
13606       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
13607       TREE_NO_WARNING (ret) = 1;
13608       return ret;
13609     }
13610   return NULL_TREE;
13611 }
13612
13613 /* A wrapper function for builtin folding that prevents warnings for
13614    "statement without effect" and the like, caused by removing the
13615    call node earlier than the warning is generated.  */
13616
13617 tree
13618 fold_call_stmt (gimple stmt, bool ignore)
13619 {
13620   tree ret = NULL_TREE;
13621   tree fndecl = gimple_call_fndecl (stmt);
13622   location_t loc = gimple_location (stmt);
13623   if (fndecl
13624       && TREE_CODE (fndecl) == FUNCTION_DECL
13625       && DECL_BUILT_IN (fndecl)
13626       && !gimple_call_va_arg_pack_p (stmt))
13627     {
13628       int nargs = gimple_call_num_args (stmt);
13629       tree *args = (nargs > 0
13630                     ? gimple_call_arg_ptr (stmt, 0)
13631                     : &error_mark_node);
13632
13633       if (avoid_folding_inline_builtin (fndecl))
13634         return NULL_TREE;
13635       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
13636         {
13637           return targetm.fold_builtin (fndecl, nargs, args, ignore);
13638         }
13639       else
13640         {
13641           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
13642             ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
13643           if (!ret)
13644             ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
13645           if (ret)
13646             {
13647               /* Propagate location information from original call to
13648                  expansion of builtin.  Otherwise things like
13649                  maybe_emit_chk_warning, that operate on the expansion
13650                  of a builtin, will use the wrong location information.  */
13651               if (gimple_has_location (stmt))
13652                 {
13653                   tree realret = ret;
13654                   if (TREE_CODE (ret) == NOP_EXPR)
13655                     realret = TREE_OPERAND (ret, 0);
13656                   if (CAN_HAVE_LOCATION_P (realret)
13657                       && !EXPR_HAS_LOCATION (realret))
13658                     SET_EXPR_LOCATION (realret, loc);
13659                   return realret;
13660                 }
13661               return ret;
13662             }
13663         }
13664     }
13665   return NULL_TREE;
13666 }
13667
13668 /* Look up the function in built_in_decls that corresponds to DECL
13669    and set ASMSPEC as its user assembler name.  DECL must be a
13670    function decl that declares a builtin.  */
13671
13672 void
13673 set_builtin_user_assembler_name (tree decl, const char *asmspec)
13674 {
13675   tree builtin;
13676   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
13677               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
13678               && asmspec != 0);
13679
13680   builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
13681   set_user_assembler_name (builtin, asmspec);
13682   switch (DECL_FUNCTION_CODE (decl))
13683     {
13684     case BUILT_IN_MEMCPY:
13685       init_block_move_fn (asmspec);
13686       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
13687       break;
13688     case BUILT_IN_MEMSET:
13689       init_block_clear_fn (asmspec);
13690       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
13691       break;
13692     case BUILT_IN_MEMMOVE:
13693       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
13694       break;
13695     case BUILT_IN_MEMCMP:
13696       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
13697       break;
13698     case BUILT_IN_ABORT:
13699       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
13700       break;
13701     case BUILT_IN_FFS:
13702       if (INT_TYPE_SIZE < BITS_PER_WORD)
13703         {
13704           set_user_assembler_libfunc ("ffs", asmspec);
13705           set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
13706                                                        MODE_INT, 0), "ffs");
13707         }
13708       break;
13709     default:
13710       break;
13711     }
13712 }
13713
13714 /* Return true if DECL is a builtin that expands to a constant or similarly
13715    simple code.  */
13716 bool
13717 is_simple_builtin (tree decl)
13718 {
13719   if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13720     switch (DECL_FUNCTION_CODE (decl))
13721       {
13722         /* Builtins that expand to constants.  */
13723       case BUILT_IN_CONSTANT_P:
13724       case BUILT_IN_EXPECT:
13725       case BUILT_IN_OBJECT_SIZE:
13726       case BUILT_IN_UNREACHABLE:
13727         /* Simple register moves or loads from stack.  */
13728       case BUILT_IN_RETURN_ADDRESS:
13729       case BUILT_IN_EXTRACT_RETURN_ADDR:
13730       case BUILT_IN_FROB_RETURN_ADDR:
13731       case BUILT_IN_RETURN:
13732       case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
13733       case BUILT_IN_FRAME_ADDRESS:
13734       case BUILT_IN_VA_END:
13735       case BUILT_IN_STACK_SAVE:
13736       case BUILT_IN_STACK_RESTORE:
13737         /* Exception state returns or moves registers around.  */
13738       case BUILT_IN_EH_FILTER:
13739       case BUILT_IN_EH_POINTER:
13740       case BUILT_IN_EH_COPY_VALUES:
13741         return true;
13742
13743       default:
13744         return false;
13745       }
13746
13747   return false;
13748 }
13749
13750 /* Return true if DECL is a builtin that is not expensive, i.e., they are
13751    most probably expanded inline into reasonably simple code.  This is a
13752    superset of is_simple_builtin.  */
13753 bool
13754 is_inexpensive_builtin (tree decl)
13755 {
13756   if (!decl)
13757     return false;
13758   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
13759     return true;
13760   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
13761     switch (DECL_FUNCTION_CODE (decl))
13762       {
13763       case BUILT_IN_ABS:
13764       case BUILT_IN_ALLOCA:
13765       case BUILT_IN_BSWAP32:
13766       case BUILT_IN_BSWAP64:
13767       case BUILT_IN_CLZ:
13768       case BUILT_IN_CLZIMAX:
13769       case BUILT_IN_CLZL:
13770       case BUILT_IN_CLZLL:
13771       case BUILT_IN_CTZ:
13772       case BUILT_IN_CTZIMAX:
13773       case BUILT_IN_CTZL:
13774       case BUILT_IN_CTZLL:
13775       case BUILT_IN_FFS:
13776       case BUILT_IN_FFSIMAX:
13777       case BUILT_IN_FFSL:
13778       case BUILT_IN_FFSLL:
13779       case BUILT_IN_IMAXABS:
13780       case BUILT_IN_FINITE:
13781       case BUILT_IN_FINITEF:
13782       case BUILT_IN_FINITEL:
13783       case BUILT_IN_FINITED32:
13784       case BUILT_IN_FINITED64:
13785       case BUILT_IN_FINITED128:
13786       case BUILT_IN_FPCLASSIFY:
13787       case BUILT_IN_ISFINITE:
13788       case BUILT_IN_ISINF_SIGN:
13789       case BUILT_IN_ISINF:
13790       case BUILT_IN_ISINFF:
13791       case BUILT_IN_ISINFL:
13792       case BUILT_IN_ISINFD32:
13793       case BUILT_IN_ISINFD64:
13794       case BUILT_IN_ISINFD128:
13795       case BUILT_IN_ISNAN:
13796       case BUILT_IN_ISNANF:
13797       case BUILT_IN_ISNANL:
13798       case BUILT_IN_ISNAND32:
13799       case BUILT_IN_ISNAND64:
13800       case BUILT_IN_ISNAND128:
13801       case BUILT_IN_ISNORMAL:
13802       case BUILT_IN_ISGREATER:
13803       case BUILT_IN_ISGREATEREQUAL:
13804       case BUILT_IN_ISLESS:
13805       case BUILT_IN_ISLESSEQUAL:
13806       case BUILT_IN_ISLESSGREATER:
13807       case BUILT_IN_ISUNORDERED:
13808       case BUILT_IN_VA_ARG_PACK:
13809       case BUILT_IN_VA_ARG_PACK_LEN:
13810       case BUILT_IN_VA_COPY:
13811       case BUILT_IN_TRAP:
13812       case BUILT_IN_SAVEREGS:
13813       case BUILT_IN_POPCOUNTL:
13814       case BUILT_IN_POPCOUNTLL:
13815       case BUILT_IN_POPCOUNTIMAX:
13816       case BUILT_IN_POPCOUNT:
13817       case BUILT_IN_PARITYL:
13818       case BUILT_IN_PARITYLL:
13819       case BUILT_IN_PARITYIMAX:
13820       case BUILT_IN_PARITY:
13821       case BUILT_IN_LABS:
13822       case BUILT_IN_LLABS:
13823       case BUILT_IN_PREFETCH:
13824         return true;
13825
13826       default:
13827         return is_simple_builtin (decl);
13828       }
13829
13830   return false;
13831 }
13832