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, 2011,
   4    2012 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 "predict.h"
  44 #include "tm_p.h"
  45 #include "target.h"
  46 #include "langhooks.h"
  47 #include "basic-block.h"
  48 #include "tree-mudflap.h"
  49 #include "tree-flow.h"
  50 #include "value-prof.h"
  51 #include "diagnostic-core.h"
  52 #include "builtins.h"
  53
  54
  55 #ifndef PAD_VARARGS_DOWN
  56 #define PAD_VARARGS_DOWN BYTES_BIG_ENDIAN
  57 #endif
  58 static tree do_mpc_arg1 (tree, tree, int (*)(mpc_ptr, mpc_srcptr, mpc_rnd_t));
  59
  60 struct target_builtins default_target_builtins;
  61 #if SWITCHABLE_TARGET
  62 struct target_builtins *this_target_builtins = &default_target_builtins;
  63 #endif
  64
  65 /* Define the names of the builtin function types and codes.  */
  66 const char *const built_in_class_names[4]
  67   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
  68
  69 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
  70 const char * built_in_names[(int) END_BUILTINS] =
  71 {
  72 #include "builtins.def"
  73 };
  74 #undef DEF_BUILTIN
  75
  76 /* Setup an array of _DECL trees, make sure each element is
  77    initialized to NULL_TREE.  */
  78 builtin_info_type builtin_info;
  79
  80 static const char *c_getstr (tree);
  81 static rtx c_readstr (const char *, enum machine_mode);
  82 static int target_char_cast (tree, char *);
  83 static rtx get_memory_rtx (tree, tree);
  84 static int apply_args_size (void);
  85 static int apply_result_size (void);
  86 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
  87 static rtx result_vector (int, rtx);
  88 #endif
  89 static void expand_builtin_update_setjmp_buf (rtx);
  90 static void expand_builtin_prefetch (tree);
  91 static rtx expand_builtin_apply_args (void);
  92 static rtx expand_builtin_apply_args_1 (void);
  93 static rtx expand_builtin_apply (rtx, rtx, rtx);
  94 static void expand_builtin_return (rtx);
  95 static enum type_class type_to_class (tree);
  96 static rtx expand_builtin_classify_type (tree);
  97 static void expand_errno_check (tree, rtx);
  98 static rtx expand_builtin_mathfn (tree, rtx, rtx);
  99 static rtx expand_builtin_mathfn_2 (tree, rtx, rtx);
 100 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
 101 static rtx expand_builtin_mathfn_ternary (tree, rtx, rtx);
 102 static rtx expand_builtin_interclass_mathfn (tree, rtx);
 103 static rtx expand_builtin_sincos (tree);
 104 static rtx expand_builtin_cexpi (tree, rtx);
 105 static rtx expand_builtin_int_roundingfn (tree, rtx);
 106 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
 107 static rtx expand_builtin_next_arg (void);
 108 static rtx expand_builtin_va_start (tree);
 109 static rtx expand_builtin_va_end (tree);
 110 static rtx expand_builtin_va_copy (tree);
 111 static rtx expand_builtin_memcmp (tree, rtx, enum machine_mode);
 112 static rtx expand_builtin_strcmp (tree, rtx);
 113 static rtx expand_builtin_strncmp (tree, rtx, enum machine_mode);
 114 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, enum machine_mode);
 115 static rtx expand_builtin_memcpy (tree, rtx);
 116 static rtx expand_builtin_mempcpy (tree, rtx, enum machine_mode);
 117 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
 118                                         enum machine_mode, int);
 119 static rtx expand_builtin_strcpy (tree, rtx);
 120 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
 121 static rtx expand_builtin_stpcpy (tree, rtx, enum machine_mode);
 122 static rtx expand_builtin_strncpy (tree, rtx);
 123 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, enum machine_mode);
 124 static rtx expand_builtin_memset (tree, rtx, enum machine_mode);
 125 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, enum machine_mode, tree);
 126 static rtx expand_builtin_bzero (tree);
 127 static rtx expand_builtin_strlen (tree, rtx, enum machine_mode);
 128 static rtx expand_builtin_alloca (tree, bool);
 129 static rtx expand_builtin_unop (enum machine_mode, tree, rtx, rtx, optab);
 130 static rtx expand_builtin_frame_address (tree, tree);
 131 static tree stabilize_va_list_loc (location_t, tree, int);
 132 static rtx expand_builtin_expect (tree, rtx);
 133 static tree fold_builtin_constant_p (tree);
 134 static tree fold_builtin_expect (location_t, tree, tree);
 135 static tree fold_builtin_classify_type (tree);
 136 static tree fold_builtin_strlen (location_t, tree, tree);
 137 static tree fold_builtin_inf (location_t, tree, int);
 138 static tree fold_builtin_nan (tree, tree, int);
 139 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
 140 static bool validate_arg (const_tree, enum tree_code code);
 141 static bool integer_valued_real_p (tree);
 142 static tree fold_trunc_transparent_mathfn (location_t, tree, tree);
 143 static bool readonly_data_expr (tree);
 144 static rtx expand_builtin_fabs (tree, rtx, rtx);
 145 static rtx expand_builtin_signbit (tree, rtx);
 146 static tree fold_builtin_sqrt (location_t, tree, tree);
 147 static tree fold_builtin_cbrt (location_t, tree, tree);
 148 static tree fold_builtin_pow (location_t, tree, tree, tree, tree);
 149 static tree fold_builtin_powi (location_t, tree, tree, tree, tree);
 150 static tree fold_builtin_cos (location_t, tree, tree, tree);
 151 static tree fold_builtin_cosh (location_t, tree, tree, tree);
 152 static tree fold_builtin_tan (tree, tree);
 153 static tree fold_builtin_trunc (location_t, tree, tree);
 154 static tree fold_builtin_floor (location_t, tree, tree);
 155 static tree fold_builtin_ceil (location_t, tree, tree);
 156 static tree fold_builtin_round (location_t, tree, tree);
 157 static tree fold_builtin_int_roundingfn (location_t, tree, tree);
 158 static tree fold_builtin_bitop (tree, tree);
 159 static tree fold_builtin_memory_op (location_t, tree, tree, tree, tree, bool, int);
 160 static tree fold_builtin_strchr (location_t, tree, tree, tree);
 161 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
 162 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
 163 static tree fold_builtin_strcmp (location_t, tree, tree);
 164 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
 165 static tree fold_builtin_signbit (location_t, tree, tree);
 166 static tree fold_builtin_copysign (location_t, tree, tree, tree, tree);
 167 static tree fold_builtin_isascii (location_t, tree);
 168 static tree fold_builtin_toascii (location_t, tree);
 169 static tree fold_builtin_isdigit (location_t, tree);
 170 static tree fold_builtin_fabs (location_t, tree, tree);
 171 static tree fold_builtin_abs (location_t, tree, tree);
 172 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
 173                                         enum tree_code);
 174 static tree fold_builtin_n (location_t, tree, tree *, int, bool);
 175 static tree fold_builtin_0 (location_t, tree, bool);
 176 static tree fold_builtin_1 (location_t, tree, tree, bool);
 177 static tree fold_builtin_2 (location_t, tree, tree, tree, bool);
 178 static tree fold_builtin_3 (location_t, tree, tree, tree, tree, bool);
 179 static tree fold_builtin_4 (location_t, tree, tree, tree, tree, tree, bool);
 180 static tree fold_builtin_varargs (location_t, tree, tree, bool);
 181
 182 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
 183 static tree fold_builtin_strstr (location_t, tree, tree, tree);
 184 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
 185 static tree fold_builtin_strcat (location_t, tree, tree);
 186 static tree fold_builtin_strncat (location_t, tree, tree, tree);
 187 static tree fold_builtin_strspn (location_t, tree, tree);
 188 static tree fold_builtin_strcspn (location_t, tree, tree);
 189 static tree fold_builtin_sprintf (location_t, tree, tree, tree, int);
 190 static tree fold_builtin_snprintf (location_t, tree, tree, tree, tree, int);
 191
 192 static rtx expand_builtin_object_size (tree);
 193 static rtx expand_builtin_memory_chk (tree, rtx, enum machine_mode,
 194                                       enum built_in_function);
 195 static void maybe_emit_chk_warning (tree, enum built_in_function);
 196 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 197 static void maybe_emit_free_warning (tree);
 198 static tree fold_builtin_object_size (tree, tree);
 199 static tree fold_builtin_strcat_chk (location_t, tree, tree, tree, tree);
 200 static tree fold_builtin_strncat_chk (location_t, tree, tree, tree, tree, tree);
 201 static tree fold_builtin_sprintf_chk (location_t, tree, enum built_in_function);
 202 static tree fold_builtin_printf (location_t, tree, tree, tree, bool, enum built_in_function);
 203 static tree fold_builtin_fprintf (location_t, tree, tree, tree, tree, bool,
 204                                   enum built_in_function);
 205 static bool init_target_chars (void);
 206
 207 static unsigned HOST_WIDE_INT target_newline;
 208 static unsigned HOST_WIDE_INT target_percent;
 209 static unsigned HOST_WIDE_INT target_c;
 210 static unsigned HOST_WIDE_INT target_s;
 211 static char target_percent_c[3];
 212 static char target_percent_s[3];
 213 static char target_percent_s_newline[4];
 214 static tree do_mpfr_arg1 (tree, tree, int (*)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
 215                           const REAL_VALUE_TYPE *, const REAL_VALUE_TYPE *, bool);
 216 static tree do_mpfr_arg2 (tree, tree, tree,
 217                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 218 static tree do_mpfr_arg3 (tree, tree, tree, tree,
 219                           int (*)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t));
 220 static tree do_mpfr_sincos (tree, tree, tree);
 221 static tree do_mpfr_bessel_n (tree, tree, tree,
 222                               int (*)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
 223                               const REAL_VALUE_TYPE *, bool);
 224 static tree do_mpfr_remquo (tree, tree, tree);
 225 static tree do_mpfr_lgamma_r (tree, tree, tree);
 226 static void expand_builtin_sync_synchronize (void);
 227
 228 /* Return true if NAME starts with __builtin_ or __sync_.  */
 229
 230 static bool
 231 is_builtin_name (const char *name)
 232 {
 233   if (strncmp (name, "__builtin_", 10) == 0)
 234     return true;
 235   if (strncmp (name, "__sync_", 7) == 0)
 236     return true;
 237   if (strncmp (name, "__atomic_", 9) == 0)
 238     return true;
 239   return false;
 240 }
 241
 242
 243 /* Return true if DECL is a function symbol representing a built-in.  */
 244
 245 bool
 246 is_builtin_fn (tree decl)
 247 {
 248   return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
 249 }
 250
 251
 252 /* Return true if NODE should be considered for inline expansion regardless
 253    of the optimization level.  This means whenever a function is invoked with
 254    its "internal" name, which normally contains the prefix "__builtin".  */
 255
 256 static bool
 257 called_as_built_in (tree node)
 258 {
 259   /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
 260      we want the name used to call the function, not the name it
 261      will have. */
 262   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 263   return is_builtin_name (name);
 264 }
 265
 266 /* Compute values M and N such that M divides (address of EXP - N) and such
 267    that N < M.  If these numbers can be determined, store M in alignp and N in
 268    *BITPOSP and return true.  Otherwise return false and store BITS_PER_UNIT to
 269    *alignp and any bit-offset to *bitposp.
 270
 271    Note that the address (and thus the alignment) computed here is based
 272    on the address to which a symbol resolves, whereas DECL_ALIGN is based
 273    on the address at which an object is actually located.  These two
 274    addresses are not always the same.  For example, on ARM targets,
 275    the address &foo of a Thumb function foo() has the lowest bit set,
 276    whereas foo() itself starts on an even address.
 277
 278    If ADDR_P is true we are taking the address of the memory reference EXP
 279    and thus cannot rely on the access taking place.  */
 280
 281 static bool
 282 get_object_alignment_2 (tree exp, unsigned int *alignp,
 283                         unsigned HOST_WIDE_INT *bitposp, bool addr_p)
 284 {
 285   HOST_WIDE_INT bitsize, bitpos;
 286   tree offset;
 287   enum machine_mode mode;
 288   int unsignedp, volatilep;
 289   unsigned int inner, align = BITS_PER_UNIT;
 290   bool known_alignment = false;
 291
 292   /* Get the innermost object and the constant (bitpos) and possibly
 293      variable (offset) offset of the access.  */
 294   exp = get_inner_reference (exp, &bitsize, &bitpos, &offset,
 295                              &mode, &unsignedp, &volatilep, true);
 296
 297   /* Extract alignment information from the innermost object and
 298      possibly adjust bitpos and offset.  */
 299   if (TREE_CODE (exp) == FUNCTION_DECL)
 300     {
 301       /* Function addresses can encode extra information besides their
 302          alignment.  However, if TARGET_PTRMEMFUNC_VBIT_LOCATION
 303          allows the low bit to be used as a virtual bit, we know
 304          that the address itself must be at least 2-byte aligned.  */
 305       if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn)
 306         align = 2 * BITS_PER_UNIT;
 307     }
 308   else if (TREE_CODE (exp) == LABEL_DECL)
 309     ;
 310   else if (TREE_CODE (exp) == CONST_DECL)
 311     {
 312       /* The alignment of a CONST_DECL is determined by its initializer.  */
 313       exp = DECL_INITIAL (exp);
 314       align = TYPE_ALIGN (TREE_TYPE (exp));
 315 #ifdef CONSTANT_ALIGNMENT
 316       if (CONSTANT_CLASS_P (exp))
 317         align = (unsigned) CONSTANT_ALIGNMENT (exp, align);
 318 #endif
 319       known_alignment = true;
 320     }
 321   else if (DECL_P (exp))
 322     {
 323       align = DECL_ALIGN (exp);
 324       known_alignment = true;
 325     }
 326   else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
 327     {
 328       align = TYPE_ALIGN (TREE_TYPE (exp));
 329     }
 330   else if (TREE_CODE (exp) == INDIRECT_REF
 331            || TREE_CODE (exp) == MEM_REF
 332            || TREE_CODE (exp) == TARGET_MEM_REF)
 333     {
 334       tree addr = TREE_OPERAND (exp, 0);
 335       unsigned ptr_align;
 336       unsigned HOST_WIDE_INT ptr_bitpos;
 337
 338       if (TREE_CODE (addr) == BIT_AND_EXPR
 339           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 340         {
 341           align = (TREE_INT_CST_LOW (TREE_OPERAND (addr, 1))
 342                     & -TREE_INT_CST_LOW (TREE_OPERAND (addr, 1)));
 343           align *= BITS_PER_UNIT;
 344           addr = TREE_OPERAND (addr, 0);
 345         }
 346
 347       known_alignment
 348         = get_pointer_alignment_1 (addr, &ptr_align, &ptr_bitpos);
 349       align = MAX (ptr_align, align);
 350
 351       /* The alignment of the pointer operand in a TARGET_MEM_REF
 352          has to take the variable offset parts into account.  */
 353       if (TREE_CODE (exp) == TARGET_MEM_REF)
 354         {
 355           if (TMR_INDEX (exp))
 356             {
 357               unsigned HOST_WIDE_INT step = 1;
 358               if (TMR_STEP (exp))
 359                 step = TREE_INT_CST_LOW (TMR_STEP (exp));
 360               align = MIN (align, (step & -step) * BITS_PER_UNIT);
 361             }
 362           if (TMR_INDEX2 (exp))
 363             align = BITS_PER_UNIT;
 364           known_alignment = false;
 365         }
 366
 367       /* When EXP is an actual memory reference then we can use
 368          TYPE_ALIGN of a pointer indirection to derive alignment.
 369          Do so only if get_pointer_alignment_1 did not reveal absolute
 370          alignment knowledge and if using that alignment would
 371          improve the situation.  */
 372       if (!addr_p && !known_alignment
 373           && TYPE_ALIGN (TREE_TYPE (exp)) > align)
 374         align = TYPE_ALIGN (TREE_TYPE (exp));
 375       else
 376         {
 377           /* Else adjust bitpos accordingly.  */
 378           bitpos += ptr_bitpos;
 379           if (TREE_CODE (exp) == MEM_REF
 380               || TREE_CODE (exp) == TARGET_MEM_REF)
 381             bitpos += mem_ref_offset (exp).low * BITS_PER_UNIT;
 382         }
 383     }
 384   else if (TREE_CODE (exp) == STRING_CST)
 385     {
 386       /* STRING_CST are the only constant objects we allow to be not
 387          wrapped inside a CONST_DECL.  */
 388       align = TYPE_ALIGN (TREE_TYPE (exp));
 389 #ifdef CONSTANT_ALIGNMENT
 390       if (CONSTANT_CLASS_P (exp))
 391         align = (unsigned) CONSTANT_ALIGNMENT (exp, align);
 392 #endif
 393       known_alignment = true;
 394     }
 395
 396   /* If there is a non-constant offset part extract the maximum
 397      alignment that can prevail.  */
 398   inner = ~0U;
 399   while (offset)
 400     {
 401       tree next_offset;
 402
 403       if (TREE_CODE (offset) == PLUS_EXPR)
 404         {
 405           next_offset = TREE_OPERAND (offset, 0);
 406           offset = TREE_OPERAND (offset, 1);
 407         }
 408       else
 409         next_offset = NULL;
 410       if (host_integerp (offset, 1))
 411         {
 412           /* Any overflow in calculating offset_bits won't change
 413              the alignment.  */
 414           unsigned offset_bits
 415             = ((unsigned) tree_low_cst (offset, 1) * BITS_PER_UNIT);
 416
 417           if (offset_bits)
 418             inner = MIN (inner, (offset_bits & -offset_bits));
 419         }
 420       else if (TREE_CODE (offset) == MULT_EXPR
 421                && host_integerp (TREE_OPERAND (offset, 1), 1))
 422         {
 423           /* Any overflow in calculating offset_factor won't change
 424              the alignment.  */
 425           unsigned offset_factor
 426             = ((unsigned) tree_low_cst (TREE_OPERAND (offset, 1), 1)
 427                * BITS_PER_UNIT);
 428
 429           if (offset_factor)
 430             inner = MIN (inner, (offset_factor & -offset_factor));
 431         }
 432       else
 433         {
 434           inner = MIN (inner, BITS_PER_UNIT);
 435           break;
 436         }
 437       offset = next_offset;
 438     }
 439   /* Alignment is innermost object alignment adjusted by the constant
 440      and non-constant offset parts.  */
 441   align = MIN (align, inner);
 442
 443   *alignp = align;
 444   *bitposp = bitpos & (*alignp - 1);
 445   return known_alignment;
 446 }
 447
 448 /* For a memory reference expression EXP compute values M and N such that M
 449    divides (&EXP - N) and such that N < M.  If these numbers can be determined,
 450    store M in alignp and N in *BITPOSP and return true.  Otherwise return false
 451    and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp.  */
 452
 453 bool
 454 get_object_alignment_1 (tree exp, unsigned int *alignp,
 455                         unsigned HOST_WIDE_INT *bitposp)
 456 {
 457   return get_object_alignment_2 (exp, alignp, bitposp, false);
 458 }
 459
 460 /* Return the alignment in bits of EXP, an object.  */
 461
 462 unsigned int
 463 get_object_alignment (tree exp)
 464 {
 465   unsigned HOST_WIDE_INT bitpos = 0;
 466   unsigned int align;
 467
 468   get_object_alignment_1 (exp, &align, &bitpos);
 469
 470   /* align and bitpos now specify known low bits of the pointer.
 471      ptr & (align - 1) == bitpos.  */
 472
 473   if (bitpos != 0)
 474     align = (bitpos & -bitpos);
 475   return align;
 476 }
 477
 478 /* For a pointer valued expression EXP compute values M and N such that M
 479    divides (EXP - N) and such that N < M.  If these numbers can be determined,
 480    store M in alignp and N in *BITPOSP and return true.  Return false if
 481    the results are just a conservative approximation.
 482
 483    If EXP is not a pointer, false is returned too.  */
 484
 485 bool
 486 get_pointer_alignment_1 (tree exp, unsigned int *alignp,
 487                          unsigned HOST_WIDE_INT *bitposp)
 488 {
 489   STRIP_NOPS (exp);
 490
 491   if (TREE_CODE (exp) == ADDR_EXPR)
 492     return get_object_alignment_2 (TREE_OPERAND (exp, 0),
 493                                    alignp, bitposp, true);
 494   else if (TREE_CODE (exp) == SSA_NAME
 495            && POINTER_TYPE_P (TREE_TYPE (exp)))
 496     {
 497       unsigned int ptr_align, ptr_misalign;
 498       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);
 499
 500       if (pi && get_ptr_info_alignment (pi, &ptr_align, &ptr_misalign))
 501         {
 502           *bitposp = ptr_misalign * BITS_PER_UNIT;
 503           *alignp = ptr_align * BITS_PER_UNIT;
 504           /* We cannot really tell whether this result is an approximation.  */
 505           return true;
 506         }
 507       else
 508         {
 509           *bitposp = 0;
 510           *alignp = BITS_PER_UNIT;
 511           return false;
 512         }
 513     }
 514   else if (TREE_CODE (exp) == INTEGER_CST)
 515     {
 516       *alignp = BIGGEST_ALIGNMENT;
 517       *bitposp = ((TREE_INT_CST_LOW (exp) * BITS_PER_UNIT)
 518                   & (BIGGEST_ALIGNMENT - 1));
 519       return true;
 520     }
 521
 522   *bitposp = 0;
 523   *alignp = BITS_PER_UNIT;
 524   return false;
 525 }
 526
 527 /* Return the alignment in bits of EXP, a pointer valued expression.
 528    The alignment returned is, by default, the alignment of the thing that
 529    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 530
 531    Otherwise, look at the expression to see if we can do better, i.e., if the
 532    expression is actually pointing at an object whose alignment is tighter.  */
 533
 534 unsigned int
 535 get_pointer_alignment (tree exp)
 536 {
 537   unsigned HOST_WIDE_INT bitpos = 0;
 538   unsigned int align;
 539
 540   get_pointer_alignment_1 (exp, &align, &bitpos);
 541
 542   /* align and bitpos now specify known low bits of the pointer.
 543      ptr & (align - 1) == bitpos.  */
 544
 545   if (bitpos != 0)
 546     align = (bitpos & -bitpos);
 547
 548   return align;
 549 }
 550
 551 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 552    way, because it could contain a zero byte in the middle.
 553    TREE_STRING_LENGTH is the size of the character array, not the string.
 554
 555    ONLY_VALUE should be nonzero if the result is not going to be emitted
 556    into the instruction stream and zero if it is going to be expanded.
 557    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 558    is returned, otherwise NULL, since
 559    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
 560    evaluate the side-effects.
 561
 562    The value returned is of type `ssizetype'.
 563
 564    Unfortunately, string_constant can't access the values of const char
 565    arrays with initializers, so neither can we do so here.  */
 566
 567 tree
 568 c_strlen (tree src, int only_value)
 569 {
 570   tree offset_node;
 571   HOST_WIDE_INT offset;
 572   int max;
 573   const char *ptr;
 574   location_t loc;
 575
 576   STRIP_NOPS (src);
 577   if (TREE_CODE (src) == COND_EXPR
 578       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 579     {
 580       tree len1, len2;
 581
 582       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
 583       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
 584       if (tree_int_cst_equal (len1, len2))
 585         return len1;
 586     }
 587
 588   if (TREE_CODE (src) == COMPOUND_EXPR
 589       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 590     return c_strlen (TREE_OPERAND (src, 1), only_value);
 591
 592   loc = EXPR_LOC_OR_HERE (src);
 593
 594   src = string_constant (src, &offset_node);
 595   if (src == 0)
 596     return NULL_TREE;
 597
 598   max = TREE_STRING_LENGTH (src) - 1;
 599   ptr = TREE_STRING_POINTER (src);
 600
 601   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 602     {
 603       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 604          compute the offset to the following null if we don't know where to
 605          start searching for it.  */
 606       int i;
 607
 608       for (i = 0; i < max; i++)
 609         if (ptr[i] == 0)
 610           return NULL_TREE;
 611
 612       /* We don't know the starting offset, but we do know that the string
 613          has no internal zero bytes.  We can assume that the offset falls
 614          within the bounds of the string; otherwise, the programmer deserves
 615          what he gets.  Subtract the offset from the length of the string,
 616          and return that.  This would perhaps not be valid if we were dealing
 617          with named arrays in addition to literal string constants.  */
 618
 619       return size_diffop_loc (loc, size_int (max), offset_node);
 620     }
 621
 622   /* We have a known offset into the string.  Start searching there for
 623      a null character if we can represent it as a single HOST_WIDE_INT.  */
 624   if (offset_node == 0)
 625     offset = 0;
 626   else if (! host_integerp (offset_node, 0))
 627     offset = -1;
 628   else
 629     offset = tree_low_cst (offset_node, 0);
 630
 631   /* If the offset is known to be out of bounds, warn, and call strlen at
 632      runtime.  */
 633   if (offset < 0 || offset > max)
 634     {
 635      /* Suppress multiple warnings for propagated constant strings.  */
 636       if (! TREE_NO_WARNING (src))
 637         {
 638           warning_at (loc, 0, "offset outside bounds of constant string");
 639           TREE_NO_WARNING (src) = 1;
 640         }
 641       return NULL_TREE;
 642     }
 643
 644   /* Use strlen to search for the first zero byte.  Since any strings
 645      constructed with build_string will have nulls appended, we win even
 646      if we get handed something like (char[4])"abcd".
 647
 648      Since OFFSET is our starting index into the string, no further
 649      calculation is needed.  */
 650   return ssize_int (strlen (ptr + offset));
 651 }
 652
 653 /* Return a char pointer for a C string if it is a string constant
 654    or sum of string constant and integer constant.  */
 655
 656 static const char *
 657 c_getstr (tree src)
 658 {
 659   tree offset_node;
 660
 661   src = string_constant (src, &offset_node);
 662   if (src == 0)
 663     return 0;
 664
 665   if (offset_node == 0)
 666     return TREE_STRING_POINTER (src);
 667   else if (!host_integerp (offset_node, 1)
 668            || compare_tree_int (offset_node, TREE_STRING_LENGTH (src) - 1) > 0)
 669     return 0;
 670
 671   return TREE_STRING_POINTER (src) + tree_low_cst (offset_node, 1);
 672 }
 673
 674 /* Return a CONST_INT or CONST_DOUBLE corresponding to target reading
 675    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 676
 677 static rtx
 678 c_readstr (const char *str, enum machine_mode mode)
 679 {
 680   HOST_WIDE_INT c[2];
 681   HOST_WIDE_INT ch;
 682   unsigned int i, j;
 683
 684   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
 685
 686   c[0] = 0;
 687   c[1] = 0;
 688   ch = 1;
 689   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 690     {
 691       j = i;
 692       if (WORDS_BIG_ENDIAN)
 693         j = GET_MODE_SIZE (mode) - i - 1;
 694       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 695           && GET_MODE_SIZE (mode) >= UNITS_PER_WORD)
 696         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 697       j *= BITS_PER_UNIT;
 698       gcc_assert (j < HOST_BITS_PER_DOUBLE_INT);
 699
 700       if (ch)
 701         ch = (unsigned char) str[i];
 702       c[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 703     }
 704   return immed_double_const (c[0], c[1], mode);
 705 }
 706
 707 /* Cast a target constant CST to target CHAR and if that value fits into
 708    host char type, return zero and put that value into variable pointed to by
 709    P.  */
 710
 711 static int
 712 target_char_cast (tree cst, char *p)
 713 {
 714   unsigned HOST_WIDE_INT val, hostval;
 715
 716   if (TREE_CODE (cst) != INTEGER_CST
 717       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 718     return 1;
 719
 720   val = TREE_INT_CST_LOW (cst);
 721   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 722     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 723
 724   hostval = val;
 725   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 726     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 727
 728   if (val != hostval)
 729     return 1;
 730
 731   *p = hostval;
 732   return 0;
 733 }
 734
 735 /* Similar to save_expr, but assumes that arbitrary code is not executed
 736    in between the multiple evaluations.  In particular, we assume that a
 737    non-addressable local variable will not be modified.  */
 738
 739 static tree
 740 builtin_save_expr (tree exp)
 741 {
 742   if (TREE_CODE (exp) == SSA_NAME
 743       || (TREE_ADDRESSABLE (exp) == 0
 744           && (TREE_CODE (exp) == PARM_DECL
 745               || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp)))))
 746     return exp;
 747
 748   return save_expr (exp);
 749 }
 750
 751 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 752    times to get the address of either a higher stack frame, or a return
 753    address located within it (depending on FNDECL_CODE).  */
 754
 755 static rtx
 756 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
 757 {
 758   int i;
 759
 760 #ifdef INITIAL_FRAME_ADDRESS_RTX
 761   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
 762 #else
 763   rtx tem;
 764
 765   /* For a zero count with __builtin_return_address, we don't care what
 766      frame address we return, because target-specific definitions will
 767      override us.  Therefore frame pointer elimination is OK, and using
 768      the soft frame pointer is OK.
 769
 770      For a nonzero count, or a zero count with __builtin_frame_address,
 771      we require a stable offset from the current frame pointer to the
 772      previous one, so we must use the hard frame pointer, and
 773      we must disable frame pointer elimination.  */
 774   if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
 775     tem = frame_pointer_rtx;
 776   else
 777     {
 778       tem = hard_frame_pointer_rtx;
 779
 780       /* Tell reload not to eliminate the frame pointer.  */
 781       crtl->accesses_prior_frames = 1;
 782     }
 783 #endif
 784
 785   /* Some machines need special handling before we can access
 786      arbitrary frames.  For example, on the SPARC, we must first flush
 787      all register windows to the stack.  */
 788 #ifdef SETUP_FRAME_ADDRESSES
 789   if (count > 0)
 790     SETUP_FRAME_ADDRESSES ();
 791 #endif
 792
 793   /* On the SPARC, the return address is not in the frame, it is in a
 794      register.  There is no way to access it off of the current frame
 795      pointer, but it can be accessed off the previous frame pointer by
 796      reading the value from the register window save area.  */
 797 #ifdef RETURN_ADDR_IN_PREVIOUS_FRAME
 798   if (fndecl_code == BUILT_IN_RETURN_ADDRESS)
 799     count--;
 800 #endif
 801
 802   /* Scan back COUNT frames to the specified frame.  */
 803   for (i = 0; i < count; i++)
 804     {
 805       /* Assume the dynamic chain pointer is in the word that the
 806          frame address points to, unless otherwise specified.  */
 807 #ifdef DYNAMIC_CHAIN_ADDRESS
 808       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 809 #endif
 810       tem = memory_address (Pmode, tem);
 811       tem = gen_frame_mem (Pmode, tem);
 812       tem = copy_to_reg (tem);
 813     }
 814
 815   /* For __builtin_frame_address, return what we've got.  But, on
 816      the SPARC for example, we may have to add a bias.  */
 817   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 818 #ifdef FRAME_ADDR_RTX
 819     return FRAME_ADDR_RTX (tem);
 820 #else
 821     return tem;
 822 #endif
 823
 824   /* For __builtin_return_address, get the return address from that frame.  */
 825 #ifdef RETURN_ADDR_RTX
 826   tem = RETURN_ADDR_RTX (count, tem);
 827 #else
 828   tem = memory_address (Pmode,
 829                         plus_constant (Pmode, tem, GET_MODE_SIZE (Pmode)));
 830   tem = gen_frame_mem (Pmode, tem);
 831 #endif
 832   return tem;
 833 }
 834
 835 /* Alias set used for setjmp buffer.  */
 836 static alias_set_type setjmp_alias_set = -1;
 837
 838 /* Construct the leading half of a __builtin_setjmp call.  Control will
 839    return to RECEIVER_LABEL.  This is also called directly by the SJLJ
 840    exception handling code.  */
 841
 842 void
 843 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 844 {
 845   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 846   rtx stack_save;
 847   rtx mem;
 848
 849   if (setjmp_alias_set == -1)
 850     setjmp_alias_set = new_alias_set ();
 851
 852   buf_addr = convert_memory_address (Pmode, buf_addr);
 853
 854   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 855
 856   /* We store the frame pointer and the address of receiver_label in
 857      the buffer and use the rest of it for the stack save area, which
 858      is machine-dependent.  */
 859
 860   mem = gen_rtx_MEM (Pmode, buf_addr);
 861   set_mem_alias_set (mem, setjmp_alias_set);
 862   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
 863
 864   mem = gen_rtx_MEM (Pmode, plus_constant (Pmode, buf_addr,
 865                                            GET_MODE_SIZE (Pmode))),
 866   set_mem_alias_set (mem, setjmp_alias_set);
 867
 868   emit_move_insn (validize_mem (mem),
 869                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 870
 871   stack_save = gen_rtx_MEM (sa_mode,
 872                             plus_constant (Pmode, buf_addr,
 873                                            2 * GET_MODE_SIZE (Pmode)));
 874   set_mem_alias_set (stack_save, setjmp_alias_set);
 875   emit_stack_save (SAVE_NONLOCAL, &stack_save);
 876
 877   /* If there is further processing to do, do it.  */
 878 #ifdef HAVE_builtin_setjmp_setup
 879   if (HAVE_builtin_setjmp_setup)
 880     emit_insn (gen_builtin_setjmp_setup (buf_addr));
 881 #endif
 882
 883   /* We have a nonlocal label.   */
 884   cfun->has_nonlocal_label = 1;
 885 }
 886
 887 /* Construct the trailing part of a __builtin_setjmp call.  This is
 888    also called directly by the SJLJ exception handling code.  */
 889
 890 void
 891 expand_builtin_setjmp_receiver (rtx receiver_label ATTRIBUTE_UNUSED)
 892 {
 893   rtx chain;
 894
 895   /* Clobber the FP when we get here, so we have to make sure it's
 896      marked as used by this function.  */
 897   emit_use (hard_frame_pointer_rtx);
 898
 899   /* Mark the static chain as clobbered here so life information
 900      doesn't get messed up for it.  */
 901   chain = targetm.calls.static_chain (current_function_decl, true);
 902   if (chain && REG_P (chain))
 903     emit_clobber (chain);
 904
 905   /* Now put in the code to restore the frame pointer, and argument
 906      pointer, if needed.  */
 907 #ifdef HAVE_nonlocal_goto
 908   if (! HAVE_nonlocal_goto)
 909 #endif
 910     {
 911       emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 912       /* This might change the hard frame pointer in ways that aren't
 913          apparent to early optimization passes, so force a clobber.  */
 914       emit_clobber (hard_frame_pointer_rtx);
 915     }
 916
 917 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
 918   if (fixed_regs[ARG_POINTER_REGNUM])
 919     {
 920 #ifdef ELIMINABLE_REGS
 921       size_t i;
 922       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 923
 924       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 925         if (elim_regs[i].from == ARG_POINTER_REGNUM
 926             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 927           break;
 928
 929       if (i == ARRAY_SIZE (elim_regs))
 930 #endif
 931         {
 932           /* Now restore our arg pointer from the address at which it
 933              was saved in our stack frame.  */
 934           emit_move_insn (crtl->args.internal_arg_pointer,
 935                           copy_to_reg (get_arg_pointer_save_area ()));
 936         }
 937     }
 938 #endif
 939
 940 #ifdef HAVE_builtin_setjmp_receiver
 941   if (HAVE_builtin_setjmp_receiver)
 942     emit_insn (gen_builtin_setjmp_receiver (receiver_label));
 943   else
 944 #endif
 945 #ifdef HAVE_nonlocal_goto_receiver
 946     if (HAVE_nonlocal_goto_receiver)
 947       emit_insn (gen_nonlocal_goto_receiver ());
 948     else
 949 #endif
 950       { /* Nothing */ }
 951
 952   /* We must not allow the code we just generated to be reordered by
 953      scheduling.  Specifically, the update of the frame pointer must
 954      happen immediately, not later.  */
 955   emit_insn (gen_blockage ());
 956 }
 957
 958 /* __builtin_longjmp is passed a pointer to an array of five words (not
 959    all will be used on all machines).  It operates similarly to the C
 960    library function of the same name, but is more efficient.  Much of
 961    the code below is copied from the handling of non-local gotos.  */
 962
 963 static void
 964 expand_builtin_longjmp (rtx buf_addr, rtx value)
 965 {
 966   rtx fp, lab, stack, insn, last;
 967   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 968
 969   /* DRAP is needed for stack realign if longjmp is expanded to current
 970      function  */
 971   if (SUPPORTS_STACK_ALIGNMENT)
 972     crtl->need_drap = true;
 973
 974   if (setjmp_alias_set == -1)
 975     setjmp_alias_set = new_alias_set ();
 976
 977   buf_addr = convert_memory_address (Pmode, buf_addr);
 978
 979   buf_addr = force_reg (Pmode, buf_addr);
 980
 981   /* We require that the user must pass a second argument of 1, because
 982      that is what builtin_setjmp will return.  */
 983   gcc_assert (value == const1_rtx);
 984
 985   last = get_last_insn ();
 986 #ifdef HAVE_builtin_longjmp
 987   if (HAVE_builtin_longjmp)
 988     emit_insn (gen_builtin_longjmp (buf_addr));
 989   else
 990 #endif
 991     {
 992       fp = gen_rtx_MEM (Pmode, buf_addr);
 993       lab = gen_rtx_MEM (Pmode, plus_constant (Pmode, buf_addr,
 994                                                GET_MODE_SIZE (Pmode)));
 995
 996       stack = gen_rtx_MEM (sa_mode, plus_constant (Pmode, buf_addr,
 997                                                    2 * GET_MODE_SIZE (Pmode)));
 998       set_mem_alias_set (fp, setjmp_alias_set);
 999       set_mem_alias_set (lab, setjmp_alias_set);
1000       set_mem_alias_set (stack, setjmp_alias_set);
1001
1002       /* Pick up FP, label, and SP from the block and jump.  This code is
1003          from expand_goto in stmt.c; see there for detailed comments.  */
1004 #ifdef HAVE_nonlocal_goto
1005       if (HAVE_nonlocal_goto)
1006         /* We have to pass a value to the nonlocal_goto pattern that will
1007            get copied into the static_chain pointer, but it does not matter
1008            what that value is, because builtin_setjmp does not use it.  */
1009         emit_insn (gen_nonlocal_goto (value, lab, stack, fp));
1010       else
1011 #endif
1012         {
1013           lab = copy_to_reg (lab);
1014
1015           emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1016           emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1017
1018           emit_move_insn (hard_frame_pointer_rtx, fp);
1019           emit_stack_restore (SAVE_NONLOCAL, stack);
1020
1021           emit_use (hard_frame_pointer_rtx);
1022           emit_use (stack_pointer_rtx);
1023           emit_indirect_jump (lab);
1024         }
1025     }
1026
1027   /* Search backwards and mark the jump insn as a non-local goto.
1028      Note that this precludes the use of __builtin_longjmp to a
1029      __builtin_setjmp target in the same function.  However, we've
1030      already cautioned the user that these functions are for
1031      internal exception handling use only.  */
1032   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1033     {
1034       gcc_assert (insn != last);
1035
1036       if (JUMP_P (insn))
1037         {
1038           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1039           break;
1040         }
1041       else if (CALL_P (insn))
1042         break;
1043     }
1044 }
1045
1046 /* Expand a call to __builtin_nonlocal_goto.  We're passed the target label
1047    and the address of the save area.  */
1048
1049 static rtx
1050 expand_builtin_nonlocal_goto (tree exp)
1051 {
1052   tree t_label, t_save_area;
1053   rtx r_label, r_save_area, r_fp, r_sp, insn;
1054
1055   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
1056     return NULL_RTX;
1057
1058   t_label = CALL_EXPR_ARG (exp, 0);
1059   t_save_area = CALL_EXPR_ARG (exp, 1);
1060
1061   r_label = expand_normal (t_label);
1062   r_label = convert_memory_address (Pmode, r_label);
1063   r_save_area = expand_normal (t_save_area);
1064   r_save_area = convert_memory_address (Pmode, r_save_area);
1065   /* Copy the address of the save location to a register just in case it was
1066      based on the frame pointer.   */
1067   r_save_area = copy_to_reg (r_save_area);
1068   r_fp = gen_rtx_MEM (Pmode, r_save_area);
1069   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
1070                       plus_constant (Pmode, r_save_area,
1071                                      GET_MODE_SIZE (Pmode)));
1072
1073   crtl->has_nonlocal_goto = 1;
1074
1075 #ifdef HAVE_nonlocal_goto
1076   /* ??? We no longer need to pass the static chain value, afaik.  */
1077   if (HAVE_nonlocal_goto)
1078     emit_insn (gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
1079   else
1080 #endif
1081     {
1082       r_label = copy_to_reg (r_label);
1083
1084       emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1085       emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1086
1087       /* Restore frame pointer for containing function.  */
1088       emit_move_insn (hard_frame_pointer_rtx, r_fp);
1089       emit_stack_restore (SAVE_NONLOCAL, r_sp);
1090
1091       /* USE of hard_frame_pointer_rtx added for consistency;
1092          not clear if really needed.  */
1093       emit_use (hard_frame_pointer_rtx);
1094       emit_use (stack_pointer_rtx);
1095
1096       /* If the architecture is using a GP register, we must
1097          conservatively assume that the target function makes use of it.
1098          The prologue of functions with nonlocal gotos must therefore
1099          initialize the GP register to the appropriate value, and we
1100          must then make sure that this value is live at the point
1101          of the jump.  (Note that this doesn't necessarily apply
1102          to targets with a nonlocal_goto pattern; they are free
1103          to implement it in their own way.  Note also that this is
1104          a no-op if the GP register is a global invariant.)  */
1105       if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
1106           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
1107         emit_use (pic_offset_table_rtx);
1108
1109       emit_indirect_jump (r_label);
1110     }
1111
1112   /* Search backwards to the jump insn and mark it as a
1113      non-local goto.  */
1114   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1115     {
1116       if (JUMP_P (insn))
1117         {
1118           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1119           break;
1120         }
1121       else if (CALL_P (insn))
1122         break;
1123     }
1124
1125   return const0_rtx;
1126 }
1127
1128 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1129    (not all will be used on all machines) that was passed to __builtin_setjmp.
1130    It updates the stack pointer in that block to correspond to the current
1131    stack pointer.  */
1132
1133 static void
1134 expand_builtin_update_setjmp_buf (rtx buf_addr)
1135 {
1136   enum machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1137   rtx stack_save
1138     = gen_rtx_MEM (sa_mode,
1139                    memory_address
1140                    (sa_mode,
1141                     plus_constant (Pmode, buf_addr,
1142                                    2 * GET_MODE_SIZE (Pmode))));
1143
1144   emit_stack_save (SAVE_NONLOCAL, &stack_save);
1145 }
1146
1147 /* Expand a call to __builtin_prefetch.  For a target that does not support
1148    data prefetch, evaluate the memory address argument in case it has side
1149    effects.  */
1150
1151 static void
1152 expand_builtin_prefetch (tree exp)
1153 {
1154   tree arg0, arg1, arg2;
1155   int nargs;
1156   rtx op0, op1, op2;
1157
1158   if (!validate_arglist (exp, POINTER_TYPE, 0))
1159     return;
1160
1161   arg0 = CALL_EXPR_ARG (exp, 0);
1162
1163   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1164      zero (read) and argument 2 (locality) defaults to 3 (high degree of
1165      locality).  */
1166   nargs = call_expr_nargs (exp);
1167   if (nargs > 1)
1168     arg1 = CALL_EXPR_ARG (exp, 1);
1169   else
1170     arg1 = integer_zero_node;
1171   if (nargs > 2)
1172     arg2 = CALL_EXPR_ARG (exp, 2);
1173   else
1174     arg2 = integer_three_node;
1175
1176   /* Argument 0 is an address.  */
1177   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1178
1179   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
1180   if (TREE_CODE (arg1) != INTEGER_CST)
1181     {
1182       error ("second argument to %<__builtin_prefetch%> must be a constant");
1183       arg1 = integer_zero_node;
1184     }
1185   op1 = expand_normal (arg1);
1186   /* Argument 1 must be either zero or one.  */
1187   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1188     {
1189       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1190                " using zero");
1191       op1 = const0_rtx;
1192     }
1193
1194   /* Argument 2 (locality) must be a compile-time constant int.  */
1195   if (TREE_CODE (arg2) != INTEGER_CST)
1196     {
1197       error ("third argument to %<__builtin_prefetch%> must be a constant");
1198       arg2 = integer_zero_node;
1199     }
1200   op2 = expand_normal (arg2);
1201   /* Argument 2 must be 0, 1, 2, or 3.  */
1202   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1203     {
1204       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1205       op2 = const0_rtx;
1206     }
1207
1208 #ifdef HAVE_prefetch
1209   if (HAVE_prefetch)
1210     {
1211       struct expand_operand ops[3];
1212
1213       create_address_operand (&ops[0], op0);
1214       create_integer_operand (&ops[1], INTVAL (op1));
1215       create_integer_operand (&ops[2], INTVAL (op2));
1216       if (maybe_expand_insn (CODE_FOR_prefetch, 3, ops))
1217         return;
1218     }
1219 #endif
1220
1221   /* Don't do anything with direct references to volatile memory, but
1222      generate code to handle other side effects.  */
1223   if (!MEM_P (op0) && side_effects_p (op0))
1224     emit_insn (op0);
1225 }
1226
1227 /* Get a MEM rtx for expression EXP which is the address of an operand
1228    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1229    the maximum length of the block of memory that might be accessed or
1230    NULL if unknown.  */
1231
1232 static rtx
1233 get_memory_rtx (tree exp, tree len)
1234 {
1235   tree orig_exp = exp;
1236   rtx addr, mem;
1237
1238   /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1239      from its expression, for expr->a.b only <variable>.a.b is recorded.  */
1240   if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1241     exp = TREE_OPERAND (exp, 0);
1242
1243   addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1244   mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1245
1246   /* Get an expression we can use to find the attributes to assign to MEM.
1247      First remove any nops.  */
1248   while (CONVERT_EXPR_P (exp)
1249          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1250     exp = TREE_OPERAND (exp, 0);
1251
1252   /* Build a MEM_REF representing the whole accessed area as a byte blob,
1253      (as builtin stringops may alias with anything).  */
1254   exp = fold_build2 (MEM_REF,
1255                      build_array_type (char_type_node,
1256                                        build_range_type (sizetype,
1257                                                          size_one_node, len)),
1258                      exp, build_int_cst (ptr_type_node, 0));
1259
1260   /* If the MEM_REF has no acceptable address, try to get the base object
1261      from the original address we got, and build an all-aliasing
1262      unknown-sized access to that one.  */
1263   if (is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
1264     set_mem_attributes (mem, exp, 0);
1265   else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1266            && (exp = get_base_address (TREE_OPERAND (TREE_OPERAND (exp, 0),
1267                                                      0))))
1268     {
1269       exp = build_fold_addr_expr (exp);
1270       exp = fold_build2 (MEM_REF,
1271                          build_array_type (char_type_node,
1272                                            build_range_type (sizetype,
1273                                                              size_zero_node,
1274                                                              NULL)),
1275                          exp, build_int_cst (ptr_type_node, 0));
1276       set_mem_attributes (mem, exp, 0);
1277     }
1278   set_mem_alias_set (mem, 0);
1279   return mem;
1280 }
1281 \f
1282 /* Built-in functions to perform an untyped call and return.  */
1283
1284 #define apply_args_mode \
1285   (this_target_builtins->x_apply_args_mode)
1286 #define apply_result_mode \
1287   (this_target_builtins->x_apply_result_mode)
1288
1289 /* Return the size required for the block returned by __builtin_apply_args,
1290    and initialize apply_args_mode.  */
1291
1292 static int
1293 apply_args_size (void)
1294 {
1295   static int size = -1;
1296   int align;
1297   unsigned int regno;
1298   enum machine_mode mode;
1299
1300   /* The values computed by this function never change.  */
1301   if (size < 0)
1302     {
1303       /* The first value is the incoming arg-pointer.  */
1304       size = GET_MODE_SIZE (Pmode);
1305
1306       /* The second value is the structure value address unless this is
1307          passed as an "invisible" first argument.  */
1308       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1309         size += GET_MODE_SIZE (Pmode);
1310
1311       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1312         if (FUNCTION_ARG_REGNO_P (regno))
1313           {
1314             mode = targetm.calls.get_raw_arg_mode (regno);
1315
1316             gcc_assert (mode != VOIDmode);
1317
1318             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1319             if (size % align != 0)
1320               size = CEIL (size, align) * align;
1321             size += GET_MODE_SIZE (mode);
1322             apply_args_mode[regno] = mode;
1323           }
1324         else
1325           {
1326             apply_args_mode[regno] = VOIDmode;
1327           }
1328     }
1329   return size;
1330 }
1331
1332 /* Return the size required for the block returned by __builtin_apply,
1333    and initialize apply_result_mode.  */
1334
1335 static int
1336 apply_result_size (void)
1337 {
1338   static int size = -1;
1339   int align, regno;
1340   enum machine_mode mode;
1341
1342   /* The values computed by this function never change.  */
1343   if (size < 0)
1344     {
1345       size = 0;
1346
1347       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1348         if (targetm.calls.function_value_regno_p (regno))
1349           {
1350             mode = targetm.calls.get_raw_result_mode (regno);
1351
1352             gcc_assert (mode != VOIDmode);
1353
1354             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1355             if (size % align != 0)
1356               size = CEIL (size, align) * align;
1357             size += GET_MODE_SIZE (mode);
1358             apply_result_mode[regno] = mode;
1359           }
1360         else
1361           apply_result_mode[regno] = VOIDmode;
1362
1363       /* Allow targets that use untyped_call and untyped_return to override
1364          the size so that machine-specific information can be stored here.  */
1365 #ifdef APPLY_RESULT_SIZE
1366       size = APPLY_RESULT_SIZE;
1367 #endif
1368     }
1369   return size;
1370 }
1371
1372 #if defined (HAVE_untyped_call) || defined (HAVE_untyped_return)
1373 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1374    the result block is used to save the values; otherwise it is used to
1375    restore the values.  */
1376
1377 static rtx
1378 result_vector (int savep, rtx result)
1379 {
1380   int regno, size, align, nelts;
1381   enum machine_mode mode;
1382   rtx reg, mem;
1383   rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1384
1385   size = nelts = 0;
1386   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1387     if ((mode = apply_result_mode[regno]) != VOIDmode)
1388       {
1389         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1390         if (size % align != 0)
1391           size = CEIL (size, align) * align;
1392         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1393         mem = adjust_address (result, mode, size);
1394         savevec[nelts++] = (savep
1395                             ? gen_rtx_SET (VOIDmode, mem, reg)
1396                             : gen_rtx_SET (VOIDmode, reg, mem));
1397         size += GET_MODE_SIZE (mode);
1398       }
1399   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1400 }
1401 #endif /* HAVE_untyped_call or HAVE_untyped_return */
1402
1403 /* Save the state required to perform an untyped call with the same
1404    arguments as were passed to the current function.  */
1405
1406 static rtx
1407 expand_builtin_apply_args_1 (void)
1408 {
1409   rtx registers, tem;
1410   int size, align, regno;
1411   enum machine_mode mode;
1412   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1413
1414   /* Create a block where the arg-pointer, structure value address,
1415      and argument registers can be saved.  */
1416   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1417
1418   /* Walk past the arg-pointer and structure value address.  */
1419   size = GET_MODE_SIZE (Pmode);
1420   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1421     size += GET_MODE_SIZE (Pmode);
1422
1423   /* Save each register used in calling a function to the block.  */
1424   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1425     if ((mode = apply_args_mode[regno]) != VOIDmode)
1426       {
1427         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1428         if (size % align != 0)
1429           size = CEIL (size, align) * align;
1430
1431         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1432
1433         emit_move_insn (adjust_address (registers, mode, size), tem);
1434         size += GET_MODE_SIZE (mode);
1435       }
1436
1437   /* Save the arg pointer to the block.  */
1438   tem = copy_to_reg (crtl->args.internal_arg_pointer);
1439 #ifdef STACK_GROWS_DOWNWARD
1440   /* We need the pointer as the caller actually passed them to us, not
1441      as we might have pretended they were passed.  Make sure it's a valid
1442      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1443   tem
1444     = force_operand (plus_constant (Pmode, tem, crtl->args.pretend_args_size),
1445                      NULL_RTX);
1446 #endif
1447   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1448
1449   size = GET_MODE_SIZE (Pmode);
1450
1451   /* Save the structure value address unless this is passed as an
1452      "invisible" first argument.  */
1453   if (struct_incoming_value)
1454     {
1455       emit_move_insn (adjust_address (registers, Pmode, size),
1456                       copy_to_reg (struct_incoming_value));
1457       size += GET_MODE_SIZE (Pmode);
1458     }
1459
1460   /* Return the address of the block.  */
1461   return copy_addr_to_reg (XEXP (registers, 0));
1462 }
1463
1464 /* __builtin_apply_args returns block of memory allocated on
1465    the stack into which is stored the arg pointer, structure
1466    value address, static chain, and all the registers that might
1467    possibly be used in performing a function call.  The code is
1468    moved to the start of the function so the incoming values are
1469    saved.  */
1470
1471 static rtx
1472 expand_builtin_apply_args (void)
1473 {
1474   /* Don't do __builtin_apply_args more than once in a function.
1475      Save the result of the first call and reuse it.  */
1476   if (apply_args_value != 0)
1477     return apply_args_value;
1478   {
1479     /* When this function is called, it means that registers must be
1480        saved on entry to this function.  So we migrate the
1481        call to the first insn of this function.  */
1482     rtx temp;
1483     rtx seq;
1484
1485     start_sequence ();
1486     temp = expand_builtin_apply_args_1 ();
1487     seq = get_insns ();
1488     end_sequence ();
1489
1490     apply_args_value = temp;
1491
1492     /* Put the insns after the NOTE that starts the function.
1493        If this is inside a start_sequence, make the outer-level insn
1494        chain current, so the code is placed at the start of the
1495        function.  If internal_arg_pointer is a non-virtual pseudo,
1496        it needs to be placed after the function that initializes
1497        that pseudo.  */
1498     push_topmost_sequence ();
1499     if (REG_P (crtl->args.internal_arg_pointer)
1500         && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1501       emit_insn_before (seq, parm_birth_insn);
1502     else
1503       emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1504     pop_topmost_sequence ();
1505     return temp;
1506   }
1507 }
1508
1509 /* Perform an untyped call and save the state required to perform an
1510    untyped return of whatever value was returned by the given function.  */
1511
1512 static rtx
1513 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1514 {
1515   int size, align, regno;
1516   enum machine_mode mode;
1517   rtx incoming_args, result, reg, dest, src, call_insn;
1518   rtx old_stack_level = 0;
1519   rtx call_fusage = 0;
1520   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1521
1522   arguments = convert_memory_address (Pmode, arguments);
1523
1524   /* Create a block where the return registers can be saved.  */
1525   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1526
1527   /* Fetch the arg pointer from the ARGUMENTS block.  */
1528   incoming_args = gen_reg_rtx (Pmode);
1529   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1530 #ifndef STACK_GROWS_DOWNWARD
1531   incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1532                                        incoming_args, 0, OPTAB_LIB_WIDEN);
1533 #endif
1534
1535   /* Push a new argument block and copy the arguments.  Do not allow
1536      the (potential) memcpy call below to interfere with our stack
1537      manipulations.  */
1538   do_pending_stack_adjust ();
1539   NO_DEFER_POP;
1540
1541   /* Save the stack with nonlocal if available.  */
1542 #ifdef HAVE_save_stack_nonlocal
1543   if (HAVE_save_stack_nonlocal)
1544     emit_stack_save (SAVE_NONLOCAL, &old_stack_level);
1545   else
1546 #endif
1547     emit_stack_save (SAVE_BLOCK, &old_stack_level);
1548
1549   /* Allocate a block of memory onto the stack and copy the memory
1550      arguments to the outgoing arguments address.  We can pass TRUE
1551      as the 4th argument because we just saved the stack pointer
1552      and will restore it right after the call.  */
1553   allocate_dynamic_stack_space (argsize, 0, BIGGEST_ALIGNMENT, true);
1554
1555   /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1556      may have already set current_function_calls_alloca to true.
1557      current_function_calls_alloca won't be set if argsize is zero,
1558      so we have to guarantee need_drap is true here.  */
1559   if (SUPPORTS_STACK_ALIGNMENT)
1560     crtl->need_drap = true;
1561
1562   dest = virtual_outgoing_args_rtx;
1563 #ifndef STACK_GROWS_DOWNWARD
1564   if (CONST_INT_P (argsize))
1565     dest = plus_constant (Pmode, dest, -INTVAL (argsize));
1566   else
1567     dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1568 #endif
1569   dest = gen_rtx_MEM (BLKmode, dest);
1570   set_mem_align (dest, PARM_BOUNDARY);
1571   src = gen_rtx_MEM (BLKmode, incoming_args);
1572   set_mem_align (src, PARM_BOUNDARY);
1573   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1574
1575   /* Refer to the argument block.  */
1576   apply_args_size ();
1577   arguments = gen_rtx_MEM (BLKmode, arguments);
1578   set_mem_align (arguments, PARM_BOUNDARY);
1579
1580   /* Walk past the arg-pointer and structure value address.  */
1581   size = GET_MODE_SIZE (Pmode);
1582   if (struct_value)
1583     size += GET_MODE_SIZE (Pmode);
1584
1585   /* Restore each of the registers previously saved.  Make USE insns
1586      for each of these registers for use in making the call.  */
1587   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1588     if ((mode = apply_args_mode[regno]) != VOIDmode)
1589       {
1590         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1591         if (size % align != 0)
1592           size = CEIL (size, align) * align;
1593         reg = gen_rtx_REG (mode, regno);
1594         emit_move_insn (reg, adjust_address (arguments, mode, size));
1595         use_reg (&call_fusage, reg);
1596         size += GET_MODE_SIZE (mode);
1597       }
1598
1599   /* Restore the structure value address unless this is passed as an
1600      "invisible" first argument.  */
1601   size = GET_MODE_SIZE (Pmode);
1602   if (struct_value)
1603     {
1604       rtx value = gen_reg_rtx (Pmode);
1605       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1606       emit_move_insn (struct_value, value);
1607       if (REG_P (struct_value))
1608         use_reg (&call_fusage, struct_value);
1609       size += GET_MODE_SIZE (Pmode);
1610     }
1611
1612   /* All arguments and registers used for the call are set up by now!  */
1613   function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1614
1615   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1616      and we don't want to load it into a register as an optimization,
1617      because prepare_call_address already did it if it should be done.  */
1618   if (GET_CODE (function) != SYMBOL_REF)
1619     function = memory_address (FUNCTION_MODE, function);
1620
1621   /* Generate the actual call instruction and save the return value.  */
1622 #ifdef HAVE_untyped_call
1623   if (HAVE_untyped_call)
1624     emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
1625                                       result, result_vector (1, result)));
1626   else
1627 #endif
1628 #ifdef HAVE_call_value
1629   if (HAVE_call_value)
1630     {
1631       rtx valreg = 0;
1632
1633       /* Locate the unique return register.  It is not possible to
1634          express a call that sets more than one return register using
1635          call_value; use untyped_call for that.  In fact, untyped_call
1636          only needs to save the return registers in the given block.  */
1637       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1638         if ((mode = apply_result_mode[regno]) != VOIDmode)
1639           {
1640             gcc_assert (!valreg); /* HAVE_untyped_call required.  */
1641
1642             valreg = gen_rtx_REG (mode, regno);
1643           }
1644
1645       emit_call_insn (GEN_CALL_VALUE (valreg,
1646                                       gen_rtx_MEM (FUNCTION_MODE, function),
1647                                       const0_rtx, NULL_RTX, const0_rtx));
1648
1649       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1650     }
1651   else
1652 #endif
1653     gcc_unreachable ();
1654
1655   /* Find the CALL insn we just emitted, and attach the register usage
1656      information.  */
1657   call_insn = last_call_insn ();
1658   add_function_usage_to (call_insn, call_fusage);
1659
1660   /* Restore the stack.  */
1661 #ifdef HAVE_save_stack_nonlocal
1662   if (HAVE_save_stack_nonlocal)
1663     emit_stack_restore (SAVE_NONLOCAL, old_stack_level);
1664   else
1665 #endif
1666     emit_stack_restore (SAVE_BLOCK, old_stack_level);
1667   fixup_args_size_notes (call_insn, get_last_insn(), 0);
1668
1669   OK_DEFER_POP;
1670
1671   /* Return the address of the result block.  */
1672   result = copy_addr_to_reg (XEXP (result, 0));
1673   return convert_memory_address (ptr_mode, result);
1674 }
1675
1676 /* Perform an untyped return.  */
1677
1678 static void
1679 expand_builtin_return (rtx result)
1680 {
1681   int size, align, regno;
1682   enum machine_mode mode;
1683   rtx reg;
1684   rtx call_fusage = 0;
1685
1686   result = convert_memory_address (Pmode, result);
1687
1688   apply_result_size ();
1689   result = gen_rtx_MEM (BLKmode, result);
1690
1691 #ifdef HAVE_untyped_return
1692   if (HAVE_untyped_return)
1693     {
1694       emit_jump_insn (gen_untyped_return (result, result_vector (0, result)));
1695       emit_barrier ();
1696       return;
1697     }
1698 #endif
1699
1700   /* Restore the return value and note that each value is used.  */
1701   size = 0;
1702   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1703     if ((mode = apply_result_mode[regno]) != VOIDmode)
1704       {
1705         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1706         if (size % align != 0)
1707           size = CEIL (size, align) * align;
1708         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1709         emit_move_insn (reg, adjust_address (result, mode, size));
1710
1711         push_to_sequence (call_fusage);
1712         emit_use (reg);
1713         call_fusage = get_insns ();
1714         end_sequence ();
1715         size += GET_MODE_SIZE (mode);
1716       }
1717
1718   /* Put the USE insns before the return.  */
1719   emit_insn (call_fusage);
1720
1721   /* Return whatever values was restored by jumping directly to the end
1722      of the function.  */
1723   expand_naked_return ();
1724 }
1725
1726 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1727
1728 static enum type_class
1729 type_to_class (tree type)
1730 {
1731   switch (TREE_CODE (type))
1732     {
1733     case VOID_TYPE:        return void_type_class;
1734     case INTEGER_TYPE:     return integer_type_class;
1735     case ENUMERAL_TYPE:    return enumeral_type_class;
1736     case BOOLEAN_TYPE:     return boolean_type_class;
1737     case POINTER_TYPE:     return pointer_type_class;
1738     case REFERENCE_TYPE:   return reference_type_class;
1739     case OFFSET_TYPE:      return offset_type_class;
1740     case REAL_TYPE:        return real_type_class;
1741     case COMPLEX_TYPE:     return complex_type_class;
1742     case FUNCTION_TYPE:    return function_type_class;
1743     case METHOD_TYPE:      return method_type_class;
1744     case RECORD_TYPE:      return record_type_class;
1745     case UNION_TYPE:
1746     case QUAL_UNION_TYPE:  return union_type_class;
1747     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1748                                    ? string_type_class : array_type_class);
1749     case LANG_TYPE:        return lang_type_class;
1750     default:               return no_type_class;
1751     }
1752 }
1753
1754 /* Expand a call EXP to __builtin_classify_type.  */
1755
1756 static rtx
1757 expand_builtin_classify_type (tree exp)
1758 {
1759   if (call_expr_nargs (exp))
1760     return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1761   return GEN_INT (no_type_class);
1762 }
1763
1764 /* This helper macro, meant to be used in mathfn_built_in below,
1765    determines which among a set of three builtin math functions is
1766    appropriate for a given type mode.  The `F' and `L' cases are
1767    automatically generated from the `double' case.  */
1768 #define CASE_MATHFN(BUILT_IN_MATHFN) \
1769   case BUILT_IN_MATHFN: case BUILT_IN_MATHFN##F: case BUILT_IN_MATHFN##L: \
1770   fcode = BUILT_IN_MATHFN; fcodef = BUILT_IN_MATHFN##F ; \
1771   fcodel = BUILT_IN_MATHFN##L ; break;
1772 /* Similar to above, but appends _R after any F/L suffix.  */
1773 #define CASE_MATHFN_REENT(BUILT_IN_MATHFN) \
1774   case BUILT_IN_MATHFN##_R: case BUILT_IN_MATHFN##F_R: case BUILT_IN_MATHFN##L_R: \
1775   fcode = BUILT_IN_MATHFN##_R; fcodef = BUILT_IN_MATHFN##F_R ; \
1776   fcodel = BUILT_IN_MATHFN##L_R ; break;
1777
1778 /* Return mathematic function equivalent to FN but operating directly on TYPE,
1779    if available.  If IMPLICIT is true use the implicit builtin declaration,
1780    otherwise use the explicit declaration.  If we can't do the conversion,
1781    return zero.  */
1782
1783 static tree
1784 mathfn_built_in_1 (tree type, enum built_in_function fn, bool implicit_p)
1785 {
1786   enum built_in_function fcode, fcodef, fcodel, fcode2;
1787
1788   switch (fn)
1789     {
1790       CASE_MATHFN (BUILT_IN_ACOS)
1791       CASE_MATHFN (BUILT_IN_ACOSH)
1792       CASE_MATHFN (BUILT_IN_ASIN)
1793       CASE_MATHFN (BUILT_IN_ASINH)
1794       CASE_MATHFN (BUILT_IN_ATAN)
1795       CASE_MATHFN (BUILT_IN_ATAN2)
1796       CASE_MATHFN (BUILT_IN_ATANH)
1797       CASE_MATHFN (BUILT_IN_CBRT)
1798       CASE_MATHFN (BUILT_IN_CEIL)
1799       CASE_MATHFN (BUILT_IN_CEXPI)
1800       CASE_MATHFN (BUILT_IN_COPYSIGN)
1801       CASE_MATHFN (BUILT_IN_COS)
1802       CASE_MATHFN (BUILT_IN_COSH)
1803       CASE_MATHFN (BUILT_IN_DREM)
1804       CASE_MATHFN (BUILT_IN_ERF)
1805       CASE_MATHFN (BUILT_IN_ERFC)
1806       CASE_MATHFN (BUILT_IN_EXP)
1807       CASE_MATHFN (BUILT_IN_EXP10)
1808       CASE_MATHFN (BUILT_IN_EXP2)
1809       CASE_MATHFN (BUILT_IN_EXPM1)
1810       CASE_MATHFN (BUILT_IN_FABS)
1811       CASE_MATHFN (BUILT_IN_FDIM)
1812       CASE_MATHFN (BUILT_IN_FLOOR)
1813       CASE_MATHFN (BUILT_IN_FMA)
1814       CASE_MATHFN (BUILT_IN_FMAX)
1815       CASE_MATHFN (BUILT_IN_FMIN)
1816       CASE_MATHFN (BUILT_IN_FMOD)
1817       CASE_MATHFN (BUILT_IN_FREXP)
1818       CASE_MATHFN (BUILT_IN_GAMMA)
1819       CASE_MATHFN_REENT (BUILT_IN_GAMMA) /* GAMMA_R */
1820       CASE_MATHFN (BUILT_IN_HUGE_VAL)
1821       CASE_MATHFN (BUILT_IN_HYPOT)
1822       CASE_MATHFN (BUILT_IN_ILOGB)
1823       CASE_MATHFN (BUILT_IN_ICEIL)
1824       CASE_MATHFN (BUILT_IN_IFLOOR)
1825       CASE_MATHFN (BUILT_IN_INF)
1826       CASE_MATHFN (BUILT_IN_IRINT)
1827       CASE_MATHFN (BUILT_IN_IROUND)
1828       CASE_MATHFN (BUILT_IN_ISINF)
1829       CASE_MATHFN (BUILT_IN_J0)
1830       CASE_MATHFN (BUILT_IN_J1)
1831       CASE_MATHFN (BUILT_IN_JN)
1832       CASE_MATHFN (BUILT_IN_LCEIL)
1833       CASE_MATHFN (BUILT_IN_LDEXP)
1834       CASE_MATHFN (BUILT_IN_LFLOOR)
1835       CASE_MATHFN (BUILT_IN_LGAMMA)
1836       CASE_MATHFN_REENT (BUILT_IN_LGAMMA) /* LGAMMA_R */
1837       CASE_MATHFN (BUILT_IN_LLCEIL)
1838       CASE_MATHFN (BUILT_IN_LLFLOOR)
1839       CASE_MATHFN (BUILT_IN_LLRINT)
1840       CASE_MATHFN (BUILT_IN_LLROUND)
1841       CASE_MATHFN (BUILT_IN_LOG)
1842       CASE_MATHFN (BUILT_IN_LOG10)
1843       CASE_MATHFN (BUILT_IN_LOG1P)
1844       CASE_MATHFN (BUILT_IN_LOG2)
1845       CASE_MATHFN (BUILT_IN_LOGB)
1846       CASE_MATHFN (BUILT_IN_LRINT)
1847       CASE_MATHFN (BUILT_IN_LROUND)
1848       CASE_MATHFN (BUILT_IN_MODF)
1849       CASE_MATHFN (BUILT_IN_NAN)
1850       CASE_MATHFN (BUILT_IN_NANS)
1851       CASE_MATHFN (BUILT_IN_NEARBYINT)
1852       CASE_MATHFN (BUILT_IN_NEXTAFTER)
1853       CASE_MATHFN (BUILT_IN_NEXTTOWARD)
1854       CASE_MATHFN (BUILT_IN_POW)
1855       CASE_MATHFN (BUILT_IN_POWI)
1856       CASE_MATHFN (BUILT_IN_POW10)
1857       CASE_MATHFN (BUILT_IN_REMAINDER)
1858       CASE_MATHFN (BUILT_IN_REMQUO)
1859       CASE_MATHFN (BUILT_IN_RINT)
1860       CASE_MATHFN (BUILT_IN_ROUND)
1861       CASE_MATHFN (BUILT_IN_SCALB)
1862       CASE_MATHFN (BUILT_IN_SCALBLN)
1863       CASE_MATHFN (BUILT_IN_SCALBN)
1864       CASE_MATHFN (BUILT_IN_SIGNBIT)
1865       CASE_MATHFN (BUILT_IN_SIGNIFICAND)
1866       CASE_MATHFN (BUILT_IN_SIN)
1867       CASE_MATHFN (BUILT_IN_SINCOS)
1868       CASE_MATHFN (BUILT_IN_SINH)
1869       CASE_MATHFN (BUILT_IN_SQRT)
1870       CASE_MATHFN (BUILT_IN_TAN)
1871       CASE_MATHFN (BUILT_IN_TANH)
1872       CASE_MATHFN (BUILT_IN_TGAMMA)
1873       CASE_MATHFN (BUILT_IN_TRUNC)
1874       CASE_MATHFN (BUILT_IN_Y0)
1875       CASE_MATHFN (BUILT_IN_Y1)
1876       CASE_MATHFN (BUILT_IN_YN)
1877
1878       default:
1879         return NULL_TREE;
1880       }
1881
1882   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1883     fcode2 = fcode;
1884   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1885     fcode2 = fcodef;
1886   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1887     fcode2 = fcodel;
1888   else
1889     return NULL_TREE;
1890
1891   if (implicit_p && !builtin_decl_implicit_p (fcode2))
1892     return NULL_TREE;
1893
1894   return builtin_decl_explicit (fcode2);
1895 }
1896
1897 /* Like mathfn_built_in_1(), but always use the implicit array.  */
1898
1899 tree
1900 mathfn_built_in (tree type, enum built_in_function fn)
1901 {
1902   return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1903 }
1904
1905 /* If errno must be maintained, expand the RTL to check if the result,
1906    TARGET, of a built-in function call, EXP, is NaN, and if so set
1907    errno to EDOM.  */
1908
1909 static void
1910 expand_errno_check (tree exp, rtx target)
1911 {
1912   rtx lab = gen_label_rtx ();
1913
1914   /* Test the result; if it is NaN, set errno=EDOM because
1915      the argument was not in the domain.  */
1916   do_compare_rtx_and_jump (target, target, EQ, 0, GET_MODE (target),
1917                            NULL_RTX, NULL_RTX, lab,
1918                            /* The jump is very likely.  */
1919                            REG_BR_PROB_BASE - (REG_BR_PROB_BASE / 2000 - 1));
1920
1921 #ifdef TARGET_EDOM
1922   /* If this built-in doesn't throw an exception, set errno directly.  */
1923   if (TREE_NOTHROW (TREE_OPERAND (CALL_EXPR_FN (exp), 0)))
1924     {
1925 #ifdef GEN_ERRNO_RTX
1926       rtx errno_rtx = GEN_ERRNO_RTX;
1927 #else
1928       rtx errno_rtx
1929           = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
1930 #endif
1931       emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
1932       emit_label (lab);
1933       return;
1934     }
1935 #endif
1936
1937   /* Make sure the library call isn't expanded as a tail call.  */
1938   CALL_EXPR_TAILCALL (exp) = 0;
1939
1940   /* We can't set errno=EDOM directly; let the library call do it.
1941      Pop the arguments right away in case the call gets deleted.  */
1942   NO_DEFER_POP;
1943   expand_call (exp, target, 0);
1944   OK_DEFER_POP;
1945   emit_label (lab);
1946 }
1947
1948 /* Expand a call to one of the builtin math functions (sqrt, exp, or log).
1949    Return NULL_RTX if a normal call should be emitted rather than expanding
1950    the function in-line.  EXP is the expression that is a call to the builtin
1951    function; if convenient, the result should be placed in TARGET.
1952    SUBTARGET may be used as the target for computing one of EXP's operands.  */
1953
1954 static rtx
1955 expand_builtin_mathfn (tree exp, rtx target, rtx subtarget)
1956 {
1957   optab builtin_optab;
1958   rtx op0, insns;
1959   tree fndecl = get_callee_fndecl (exp);
1960   enum machine_mode mode;
1961   bool errno_set = false;
1962   tree arg;
1963
1964   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
1965     return NULL_RTX;
1966
1967   arg = CALL_EXPR_ARG (exp, 0);
1968
1969   switch (DECL_FUNCTION_CODE (fndecl))
1970     {
1971     CASE_FLT_FN (BUILT_IN_SQRT):
1972       errno_set = ! tree_expr_nonnegative_p (arg);
1973       builtin_optab = sqrt_optab;
1974       break;
1975     CASE_FLT_FN (BUILT_IN_EXP):
1976       errno_set = true; builtin_optab = exp_optab; break;
1977     CASE_FLT_FN (BUILT_IN_EXP10):
1978     CASE_FLT_FN (BUILT_IN_POW10):
1979       errno_set = true; builtin_optab = exp10_optab; break;
1980     CASE_FLT_FN (BUILT_IN_EXP2):
1981       errno_set = true; builtin_optab = exp2_optab; break;
1982     CASE_FLT_FN (BUILT_IN_EXPM1):
1983       errno_set = true; builtin_optab = expm1_optab; break;
1984     CASE_FLT_FN (BUILT_IN_LOGB):
1985       errno_set = true; builtin_optab = logb_optab; break;
1986     CASE_FLT_FN (BUILT_IN_LOG):
1987       errno_set = true; builtin_optab = log_optab; break;
1988     CASE_FLT_FN (BUILT_IN_LOG10):
1989       errno_set = true; builtin_optab = log10_optab; break;
1990     CASE_FLT_FN (BUILT_IN_LOG2):
1991       errno_set = true; builtin_optab = log2_optab; break;
1992     CASE_FLT_FN (BUILT_IN_LOG1P):
1993       errno_set = true; builtin_optab = log1p_optab; break;
1994     CASE_FLT_FN (BUILT_IN_ASIN):
1995       builtin_optab = asin_optab; break;
1996     CASE_FLT_FN (BUILT_IN_ACOS):
1997       builtin_optab = acos_optab; break;
1998     CASE_FLT_FN (BUILT_IN_TAN):
1999       builtin_optab = tan_optab; break;
2000     CASE_FLT_FN (BUILT_IN_ATAN):
2001       builtin_optab = atan_optab; break;
2002     CASE_FLT_FN (BUILT_IN_FLOOR):
2003       builtin_optab = floor_optab; break;
2004     CASE_FLT_FN (BUILT_IN_CEIL):
2005       builtin_optab = ceil_optab; break;
2006     CASE_FLT_FN (BUILT_IN_TRUNC):
2007       builtin_optab = btrunc_optab; break;
2008     CASE_FLT_FN (BUILT_IN_ROUND):
2009       builtin_optab = round_optab; break;
2010     CASE_FLT_FN (BUILT_IN_NEARBYINT):
2011       builtin_optab = nearbyint_optab;
2012       if (flag_trapping_math)
2013         break;
2014       /* Else fallthrough and expand as rint.  */
2015     CASE_FLT_FN (BUILT_IN_RINT):
2016       builtin_optab = rint_optab; break;
2017     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
2018       builtin_optab = significand_optab; break;
2019     default:
2020       gcc_unreachable ();
2021     }
2022
2023   /* Make a suitable register to place result in.  */
2024   mode = TYPE_MODE (TREE_TYPE (exp));
2025
2026   if (! flag_errno_math || ! HONOR_NANS (mode))
2027     errno_set = false;
2028
2029   /* Before working hard, check whether the instruction is available.  */
2030   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing
2031       && (!errno_set || !optimize_insn_for_size_p ()))
2032     {
2033       target = gen_reg_rtx (mode);
2034
2035       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2036          need to expand the argument again.  This way, we will not perform
2037          side-effects more the once.  */
2038       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2039
2040       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2041
2042       start_sequence ();
2043
2044       /* Compute into TARGET.
2045          Set TARGET to wherever the result comes back.  */
2046       target = expand_unop (mode, builtin_optab, op0, target, 0);
2047
2048       if (target != 0)
2049         {
2050           if (errno_set)
2051             expand_errno_check (exp, target);
2052
2053           /* Output the entire sequence.  */
2054           insns = get_insns ();
2055           end_sequence ();
2056           emit_insn (insns);
2057           return target;
2058         }
2059
2060       /* If we were unable to expand via the builtin, stop the sequence
2061          (without outputting the insns) and call to the library function
2062          with the stabilized argument list.  */
2063       end_sequence ();
2064     }
2065
2066   return expand_call (exp, target, target == const0_rtx);
2067 }
2068
2069 /* Expand a call to the builtin binary math functions (pow and atan2).
2070    Return NULL_RTX if a normal call should be emitted rather than expanding the
2071    function in-line.  EXP is the expression that is a call to the builtin
2072    function; if convenient, the result should be placed in TARGET.
2073    SUBTARGET may be used as the target for computing one of EXP's
2074    operands.  */
2075
2076 static rtx
2077 expand_builtin_mathfn_2 (tree exp, rtx target, rtx subtarget)
2078 {
2079   optab builtin_optab;
2080   rtx op0, op1, insns;
2081   int op1_type = REAL_TYPE;
2082   tree fndecl = get_callee_fndecl (exp);
2083   tree arg0, arg1;
2084   enum machine_mode mode;
2085   bool errno_set = true;
2086
2087   switch (DECL_FUNCTION_CODE (fndecl))
2088     {
2089     CASE_FLT_FN (BUILT_IN_SCALBN):
2090     CASE_FLT_FN (BUILT_IN_SCALBLN):
2091     CASE_FLT_FN (BUILT_IN_LDEXP):
2092       op1_type = INTEGER_TYPE;
2093     default:
2094       break;
2095     }
2096
2097   if (!validate_arglist (exp, REAL_TYPE, op1_type, VOID_TYPE))
2098     return NULL_RTX;
2099
2100   arg0 = CALL_EXPR_ARG (exp, 0);
2101   arg1 = CALL_EXPR_ARG (exp, 1);
2102
2103   switch (DECL_FUNCTION_CODE (fndecl))
2104     {
2105     CASE_FLT_FN (BUILT_IN_POW):
2106       builtin_optab = pow_optab; break;
2107     CASE_FLT_FN (BUILT_IN_ATAN2):
2108       builtin_optab = atan2_optab; break;
2109     CASE_FLT_FN (BUILT_IN_SCALB):
2110       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2111         return 0;
2112       builtin_optab = scalb_optab; break;
2113     CASE_FLT_FN (BUILT_IN_SCALBN):
2114     CASE_FLT_FN (BUILT_IN_SCALBLN):
2115       if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (exp)))->b != 2)
2116         return 0;
2117     /* Fall through... */
2118     CASE_FLT_FN (BUILT_IN_LDEXP):
2119       builtin_optab = ldexp_optab; break;
2120     CASE_FLT_FN (BUILT_IN_FMOD):
2121       builtin_optab = fmod_optab; break;
2122     CASE_FLT_FN (BUILT_IN_REMAINDER):
2123     CASE_FLT_FN (BUILT_IN_DREM):
2124       builtin_optab = remainder_optab; break;
2125     default:
2126       gcc_unreachable ();
2127     }
2128
2129   /* Make a suitable register to place result in.  */
2130   mode = TYPE_MODE (TREE_TYPE (exp));
2131
2132   /* Before working hard, check whether the instruction is available.  */
2133   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2134     return NULL_RTX;
2135
2136   target = gen_reg_rtx (mode);
2137
2138   if (! flag_errno_math || ! HONOR_NANS (mode))
2139     errno_set = false;
2140
2141   if (errno_set && optimize_insn_for_size_p ())
2142     return 0;
2143
2144   /* Always stabilize the argument list.  */
2145   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2146   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2147
2148   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2149   op1 = expand_normal (arg1);
2150
2151   start_sequence ();
2152
2153   /* Compute into TARGET.
2154      Set TARGET to wherever the result comes back.  */
2155   target = expand_binop (mode, builtin_optab, op0, op1,
2156                          target, 0, OPTAB_DIRECT);
2157
2158   /* If we were unable to expand via the builtin, stop the sequence
2159      (without outputting the insns) and call to the library function
2160      with the stabilized argument list.  */
2161   if (target == 0)
2162     {
2163       end_sequence ();
2164       return expand_call (exp, target, target == const0_rtx);
2165     }
2166
2167   if (errno_set)
2168     expand_errno_check (exp, target);
2169
2170   /* Output the entire sequence.  */
2171   insns = get_insns ();
2172   end_sequence ();
2173   emit_insn (insns);
2174
2175   return target;
2176 }
2177
2178 /* Expand a call to the builtin trinary math functions (fma).
2179    Return NULL_RTX if a normal call should be emitted rather than expanding the
2180    function in-line.  EXP is the expression that is a call to the builtin
2181    function; if convenient, the result should be placed in TARGET.
2182    SUBTARGET may be used as the target for computing one of EXP's
2183    operands.  */
2184
2185 static rtx
2186 expand_builtin_mathfn_ternary (tree exp, rtx target, rtx subtarget)
2187 {
2188   optab builtin_optab;
2189   rtx op0, op1, op2, insns;
2190   tree fndecl = get_callee_fndecl (exp);
2191   tree arg0, arg1, arg2;
2192   enum machine_mode mode;
2193
2194   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, REAL_TYPE, VOID_TYPE))
2195     return NULL_RTX;
2196
2197   arg0 = CALL_EXPR_ARG (exp, 0);
2198   arg1 = CALL_EXPR_ARG (exp, 1);
2199   arg2 = CALL_EXPR_ARG (exp, 2);
2200
2201   switch (DECL_FUNCTION_CODE (fndecl))
2202     {
2203     CASE_FLT_FN (BUILT_IN_FMA):
2204       builtin_optab = fma_optab; break;
2205     default:
2206       gcc_unreachable ();
2207     }
2208
2209   /* Make a suitable register to place result in.  */
2210   mode = TYPE_MODE (TREE_TYPE (exp));
2211
2212   /* Before working hard, check whether the instruction is available.  */
2213   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2214     return NULL_RTX;
2215
2216   target = gen_reg_rtx (mode);
2217
2218   /* Always stabilize the argument list.  */
2219   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2220   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2221   CALL_EXPR_ARG (exp, 2) = arg2 = builtin_save_expr (arg2);
2222
2223   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2224   op1 = expand_normal (arg1);
2225   op2 = expand_normal (arg2);
2226
2227   start_sequence ();
2228
2229   /* Compute into TARGET.
2230      Set TARGET to wherever the result comes back.  */
2231   target = expand_ternary_op (mode, builtin_optab, op0, op1, op2,
2232                               target, 0);
2233
2234   /* If we were unable to expand via the builtin, stop the sequence
2235      (without outputting the insns) and call to the library function
2236      with the stabilized argument list.  */
2237   if (target == 0)
2238     {
2239       end_sequence ();
2240       return expand_call (exp, target, target == const0_rtx);
2241     }
2242
2243   /* Output the entire sequence.  */
2244   insns = get_insns ();
2245   end_sequence ();
2246   emit_insn (insns);
2247
2248   return target;
2249 }
2250
2251 /* Expand a call to the builtin sin and cos math functions.
2252    Return NULL_RTX if a normal call should be emitted rather than expanding the
2253    function in-line.  EXP is the expression that is a call to the builtin
2254    function; if convenient, the result should be placed in TARGET.
2255    SUBTARGET may be used as the target for computing one of EXP's
2256    operands.  */
2257
2258 static rtx
2259 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2260 {
2261   optab builtin_optab;
2262   rtx op0, insns;
2263   tree fndecl = get_callee_fndecl (exp);
2264   enum machine_mode mode;
2265   tree arg;
2266
2267   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2268     return NULL_RTX;
2269
2270   arg = CALL_EXPR_ARG (exp, 0);
2271
2272   switch (DECL_FUNCTION_CODE (fndecl))
2273     {
2274     CASE_FLT_FN (BUILT_IN_SIN):
2275     CASE_FLT_FN (BUILT_IN_COS):
2276       builtin_optab = sincos_optab; break;
2277     default:
2278       gcc_unreachable ();
2279     }
2280
2281   /* Make a suitable register to place result in.  */
2282   mode = TYPE_MODE (TREE_TYPE (exp));
2283
2284   /* Check if sincos insn is available, otherwise fallback
2285      to sin or cos insn.  */
2286   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2287     switch (DECL_FUNCTION_CODE (fndecl))
2288       {
2289       CASE_FLT_FN (BUILT_IN_SIN):
2290         builtin_optab = sin_optab; break;
2291       CASE_FLT_FN (BUILT_IN_COS):
2292         builtin_optab = cos_optab; break;
2293       default:
2294         gcc_unreachable ();
2295       }
2296
2297   /* Before working hard, check whether the instruction is available.  */
2298   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2299     {
2300       target = gen_reg_rtx (mode);
2301
2302       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2303          need to expand the argument again.  This way, we will not perform
2304          side-effects more the once.  */
2305       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2306
2307       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2308
2309       start_sequence ();
2310
2311       /* Compute into TARGET.
2312          Set TARGET to wherever the result comes back.  */
2313       if (builtin_optab == sincos_optab)
2314         {
2315           int result;
2316
2317           switch (DECL_FUNCTION_CODE (fndecl))
2318             {
2319             CASE_FLT_FN (BUILT_IN_SIN):
2320               result = expand_twoval_unop (builtin_optab, op0, 0, target, 0);
2321               break;
2322             CASE_FLT_FN (BUILT_IN_COS):
2323               result = expand_twoval_unop (builtin_optab, op0, target, 0, 0);
2324               break;
2325             default:
2326               gcc_unreachable ();
2327             }
2328           gcc_assert (result);
2329         }
2330       else
2331         {
2332           target = expand_unop (mode, builtin_optab, op0, target, 0);
2333         }
2334
2335       if (target != 0)
2336         {
2337           /* Output the entire sequence.  */
2338           insns = get_insns ();
2339           end_sequence ();
2340           emit_insn (insns);
2341           return target;
2342         }
2343
2344       /* If we were unable to expand via the builtin, stop the sequence
2345          (without outputting the insns) and call to the library function
2346          with the stabilized argument list.  */
2347       end_sequence ();
2348     }
2349
2350   target = expand_call (exp, target, target == const0_rtx);
2351
2352   return target;
2353 }
2354
2355 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2356    return an RTL instruction code that implements the functionality.
2357    If that isn't possible or available return CODE_FOR_nothing.  */
2358
2359 static enum insn_code
2360 interclass_mathfn_icode (tree arg, tree fndecl)
2361 {
2362   bool errno_set = false;
2363   optab builtin_optab = unknown_optab;
2364   enum machine_mode mode;
2365
2366   switch (DECL_FUNCTION_CODE (fndecl))
2367     {
2368     CASE_FLT_FN (BUILT_IN_ILOGB):
2369       errno_set = true; builtin_optab = ilogb_optab; break;
2370     CASE_FLT_FN (BUILT_IN_ISINF):
2371       builtin_optab = isinf_optab; break;
2372     case BUILT_IN_ISNORMAL:
2373     case BUILT_IN_ISFINITE:
2374     CASE_FLT_FN (BUILT_IN_FINITE):
2375     case BUILT_IN_FINITED32:
2376     case BUILT_IN_FINITED64:
2377     case BUILT_IN_FINITED128:
2378     case BUILT_IN_ISINFD32:
2379     case BUILT_IN_ISINFD64:
2380     case BUILT_IN_ISINFD128:
2381       /* These builtins have no optabs (yet).  */
2382       break;
2383     default:
2384       gcc_unreachable ();
2385     }
2386
2387   /* There's no easy way to detect the case we need to set EDOM.  */
2388   if (flag_errno_math && errno_set)
2389     return CODE_FOR_nothing;
2390
2391   /* Optab mode depends on the mode of the input argument.  */
2392   mode = TYPE_MODE (TREE_TYPE (arg));
2393
2394   if (builtin_optab)
2395     return optab_handler (builtin_optab, mode);
2396   return CODE_FOR_nothing;
2397 }
2398
2399 /* Expand a call to one of the builtin math functions that operate on
2400    floating point argument and output an integer result (ilogb, isinf,
2401    isnan, etc).
2402    Return 0 if a normal call should be emitted rather than expanding the
2403    function in-line.  EXP is the expression that is a call to the builtin
2404    function; if convenient, the result should be placed in TARGET.  */
2405
2406 static rtx
2407 expand_builtin_interclass_mathfn (tree exp, rtx target)
2408 {
2409   enum insn_code icode = CODE_FOR_nothing;
2410   rtx op0;
2411   tree fndecl = get_callee_fndecl (exp);
2412   enum machine_mode mode;
2413   tree arg;
2414
2415   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2416     return NULL_RTX;
2417
2418   arg = CALL_EXPR_ARG (exp, 0);
2419   icode = interclass_mathfn_icode (arg, fndecl);
2420   mode = TYPE_MODE (TREE_TYPE (arg));
2421
2422   if (icode != CODE_FOR_nothing)
2423     {
2424       struct expand_operand ops[1];
2425       rtx last = get_last_insn ();
2426       tree orig_arg = arg;
2427
2428       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2429          need to expand the argument again.  This way, we will not perform
2430          side-effects more the once.  */
2431       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2432
2433       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2434
2435       if (mode != GET_MODE (op0))
2436         op0 = convert_to_mode (mode, op0, 0);
2437
2438       create_output_operand (&ops[0], target, TYPE_MODE (TREE_TYPE (exp)));
2439       if (maybe_legitimize_operands (icode, 0, 1, ops)
2440           && maybe_emit_unop_insn (icode, ops[0].value, op0, UNKNOWN))
2441         return ops[0].value;
2442
2443       delete_insns_since (last);
2444       CALL_EXPR_ARG (exp, 0) = orig_arg;
2445     }
2446
2447   return NULL_RTX;
2448 }
2449
2450 /* Expand a call to the builtin sincos math function.
2451    Return NULL_RTX if a normal call should be emitted rather than expanding the
2452    function in-line.  EXP is the expression that is a call to the builtin
2453    function.  */
2454
2455 static rtx
2456 expand_builtin_sincos (tree exp)
2457 {
2458   rtx op0, op1, op2, target1, target2;
2459   enum machine_mode mode;
2460   tree arg, sinp, cosp;
2461   int result;
2462   location_t loc = EXPR_LOCATION (exp);
2463   tree alias_type, alias_off;
2464
2465   if (!validate_arglist (exp, REAL_TYPE,
2466                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2467     return NULL_RTX;
2468
2469   arg = CALL_EXPR_ARG (exp, 0);
2470   sinp = CALL_EXPR_ARG (exp, 1);
2471   cosp = CALL_EXPR_ARG (exp, 2);
2472
2473   /* Make a suitable register to place result in.  */
2474   mode = TYPE_MODE (TREE_TYPE (arg));
2475
2476   /* Check if sincos insn is available, otherwise emit the call.  */
2477   if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2478     return NULL_RTX;
2479
2480   target1 = gen_reg_rtx (mode);
2481   target2 = gen_reg_rtx (mode);
2482
2483   op0 = expand_normal (arg);
2484   alias_type = build_pointer_type_for_mode (TREE_TYPE (arg), ptr_mode, true);
2485   alias_off = build_int_cst (alias_type, 0);
2486   op1 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2487                                         sinp, alias_off));
2488   op2 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2489                                         cosp, alias_off));
2490
2491   /* Compute into target1 and target2.
2492      Set TARGET to wherever the result comes back.  */
2493   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2494   gcc_assert (result);
2495
2496   /* Move target1 and target2 to the memory locations indicated
2497      by op1 and op2.  */
2498   emit_move_insn (op1, target1);
2499   emit_move_insn (op2, target2);
2500
2501   return const0_rtx;
2502 }
2503
2504 /* Expand a call to the internal cexpi builtin to the sincos math function.
2505    EXP is the expression that is a call to the builtin function; if convenient,
2506    the result should be placed in TARGET.  */
2507
2508 static rtx
2509 expand_builtin_cexpi (tree exp, rtx target)
2510 {
2511   tree fndecl = get_callee_fndecl (exp);
2512   tree arg, type;
2513   enum machine_mode mode;
2514   rtx op0, op1, op2;
2515   location_t loc = EXPR_LOCATION (exp);
2516
2517   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2518     return NULL_RTX;
2519
2520   arg = CALL_EXPR_ARG (exp, 0);
2521   type = TREE_TYPE (arg);
2522   mode = TYPE_MODE (TREE_TYPE (arg));
2523
2524   /* Try expanding via a sincos optab, fall back to emitting a libcall
2525      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2526      is only generated from sincos, cexp or if we have either of them.  */
2527   if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2528     {
2529       op1 = gen_reg_rtx (mode);
2530       op2 = gen_reg_rtx (mode);
2531
2532       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2533
2534       /* Compute into op1 and op2.  */
2535       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2536     }
2537   else if (TARGET_HAS_SINCOS)
2538     {
2539       tree call, fn = NULL_TREE;
2540       tree top1, top2;
2541       rtx op1a, op2a;
2542
2543       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2544         fn = builtin_decl_explicit (BUILT_IN_SINCOSF);
2545       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2546         fn = builtin_decl_explicit (BUILT_IN_SINCOS);
2547       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2548         fn = builtin_decl_explicit (BUILT_IN_SINCOSL);
2549       else
2550         gcc_unreachable ();
2551
2552       op1 = assign_temp (TREE_TYPE (arg), 1, 1);
2553       op2 = assign_temp (TREE_TYPE (arg), 1, 1);
2554       op1a = copy_addr_to_reg (XEXP (op1, 0));
2555       op2a = copy_addr_to_reg (XEXP (op2, 0));
2556       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2557       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2558
2559       /* Make sure not to fold the sincos call again.  */
2560       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2561       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2562                                       call, 3, arg, top1, top2));
2563     }
2564   else
2565     {
2566       tree call, fn = NULL_TREE, narg;
2567       tree ctype = build_complex_type (type);
2568
2569       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2570         fn = builtin_decl_explicit (BUILT_IN_CEXPF);
2571       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2572         fn = builtin_decl_explicit (BUILT_IN_CEXP);
2573       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2574         fn = builtin_decl_explicit (BUILT_IN_CEXPL);
2575       else
2576         gcc_unreachable ();
2577
2578       /* If we don't have a decl for cexp create one.  This is the
2579          friendliest fallback if the user calls __builtin_cexpi
2580          without full target C99 function support.  */
2581       if (fn == NULL_TREE)
2582         {
2583           tree fntype;
2584           const char *name = NULL;
2585
2586           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2587             name = "cexpf";
2588           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2589             name = "cexp";
2590           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2591             name = "cexpl";
2592
2593           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2594           fn = build_fn_decl (name, fntype);
2595         }
2596
2597       narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2598                           build_real (type, dconst0), arg);
2599
2600       /* Make sure not to fold the cexp call again.  */
2601       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2602       return expand_expr (build_call_nary (ctype, call, 1, narg),
2603                           target, VOIDmode, EXPAND_NORMAL);
2604     }
2605
2606   /* Now build the proper return type.  */
2607   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2608                               make_tree (TREE_TYPE (arg), op2),
2609                               make_tree (TREE_TYPE (arg), op1)),
2610                       target, VOIDmode, EXPAND_NORMAL);
2611 }
2612
2613 /* Conveniently construct a function call expression.  FNDECL names the
2614    function to be called, N is the number of arguments, and the "..."
2615    parameters are the argument expressions.  Unlike build_call_exr
2616    this doesn't fold the call, hence it will always return a CALL_EXPR.  */
2617
2618 static tree
2619 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2620 {
2621   va_list ap;
2622   tree fntype = TREE_TYPE (fndecl);
2623   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2624
2625   va_start (ap, n);
2626   fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2627   va_end (ap);
2628   SET_EXPR_LOCATION (fn, loc);
2629   return fn;
2630 }
2631
2632 /* Expand a call to one of the builtin rounding functions gcc defines
2633    as an extension (lfloor and lceil).  As these are gcc extensions we
2634    do not need to worry about setting errno to EDOM.
2635    If expanding via optab fails, lower expression to (int)(floor(x)).
2636    EXP is the expression that is a call to the builtin function;
2637    if convenient, the result should be placed in TARGET.  */
2638
2639 static rtx
2640 expand_builtin_int_roundingfn (tree exp, rtx target)
2641 {
2642   convert_optab builtin_optab;
2643   rtx op0, insns, tmp;
2644   tree fndecl = get_callee_fndecl (exp);
2645   enum built_in_function fallback_fn;
2646   tree fallback_fndecl;
2647   enum machine_mode mode;
2648   tree arg;
2649
2650   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2651     gcc_unreachable ();
2652
2653   arg = CALL_EXPR_ARG (exp, 0);
2654
2655   switch (DECL_FUNCTION_CODE (fndecl))
2656     {
2657     CASE_FLT_FN (BUILT_IN_ICEIL):
2658     CASE_FLT_FN (BUILT_IN_LCEIL):
2659     CASE_FLT_FN (BUILT_IN_LLCEIL):
2660       builtin_optab = lceil_optab;
2661       fallback_fn = BUILT_IN_CEIL;
2662       break;
2663
2664     CASE_FLT_FN (BUILT_IN_IFLOOR):
2665     CASE_FLT_FN (BUILT_IN_LFLOOR):
2666     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2667       builtin_optab = lfloor_optab;
2668       fallback_fn = BUILT_IN_FLOOR;
2669       break;
2670
2671     default:
2672       gcc_unreachable ();
2673     }
2674
2675   /* Make a suitable register to place result in.  */
2676   mode = TYPE_MODE (TREE_TYPE (exp));
2677
2678   target = gen_reg_rtx (mode);
2679
2680   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2681      need to expand the argument again.  This way, we will not perform
2682      side-effects more the once.  */
2683   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2684
2685   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2686
2687   start_sequence ();
2688
2689   /* Compute into TARGET.  */
2690   if (expand_sfix_optab (target, op0, builtin_optab))
2691     {
2692       /* Output the entire sequence.  */
2693       insns = get_insns ();
2694       end_sequence ();
2695       emit_insn (insns);
2696       return target;
2697     }
2698
2699   /* If we were unable to expand via the builtin, stop the sequence
2700      (without outputting the insns).  */
2701   end_sequence ();
2702
2703   /* Fall back to floating point rounding optab.  */
2704   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2705
2706   /* For non-C99 targets we may end up without a fallback fndecl here
2707      if the user called __builtin_lfloor directly.  In this case emit
2708      a call to the floor/ceil variants nevertheless.  This should result
2709      in the best user experience for not full C99 targets.  */
2710   if (fallback_fndecl == NULL_TREE)
2711     {
2712       tree fntype;
2713       const char *name = NULL;
2714
2715       switch (DECL_FUNCTION_CODE (fndecl))
2716         {
2717         case BUILT_IN_ICEIL:
2718         case BUILT_IN_LCEIL:
2719         case BUILT_IN_LLCEIL:
2720           name = "ceil";
2721           break;
2722         case BUILT_IN_ICEILF:
2723         case BUILT_IN_LCEILF:
2724         case BUILT_IN_LLCEILF:
2725           name = "ceilf";
2726           break;
2727         case BUILT_IN_ICEILL:
2728         case BUILT_IN_LCEILL:
2729         case BUILT_IN_LLCEILL:
2730           name = "ceill";
2731           break;
2732         case BUILT_IN_IFLOOR:
2733         case BUILT_IN_LFLOOR:
2734         case BUILT_IN_LLFLOOR:
2735           name = "floor";
2736           break;
2737         case BUILT_IN_IFLOORF:
2738         case BUILT_IN_LFLOORF:
2739         case BUILT_IN_LLFLOORF:
2740           name = "floorf";
2741           break;
2742         case BUILT_IN_IFLOORL:
2743         case BUILT_IN_LFLOORL:
2744         case BUILT_IN_LLFLOORL:
2745           name = "floorl";
2746           break;
2747         default:
2748           gcc_unreachable ();
2749         }
2750
2751       fntype = build_function_type_list (TREE_TYPE (arg),
2752                                          TREE_TYPE (arg), NULL_TREE);
2753       fallback_fndecl = build_fn_decl (name, fntype);
2754     }
2755
2756   exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2757
2758   tmp = expand_normal (exp);
2759
2760   /* Truncate the result of floating point optab to integer
2761      via expand_fix ().  */
2762   target = gen_reg_rtx (mode);
2763   expand_fix (target, tmp, 0);
2764
2765   return target;
2766 }
2767
2768 /* Expand a call to one of the builtin math functions doing integer
2769    conversion (lrint).
2770    Return 0 if a normal call should be emitted rather than expanding the
2771    function in-line.  EXP is the expression that is a call to the builtin
2772    function; if convenient, the result should be placed in TARGET.  */
2773
2774 static rtx
2775 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2776 {
2777   convert_optab builtin_optab;
2778   rtx op0, insns;
2779   tree fndecl = get_callee_fndecl (exp);
2780   tree arg;
2781   enum machine_mode mode;
2782   enum built_in_function fallback_fn = BUILT_IN_NONE;
2783
2784   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2785      gcc_unreachable ();
2786
2787   arg = CALL_EXPR_ARG (exp, 0);
2788
2789   switch (DECL_FUNCTION_CODE (fndecl))
2790     {
2791     CASE_FLT_FN (BUILT_IN_IRINT):
2792       fallback_fn = BUILT_IN_LRINT;
2793       /* FALLTHRU */
2794     CASE_FLT_FN (BUILT_IN_LRINT):
2795     CASE_FLT_FN (BUILT_IN_LLRINT):
2796       builtin_optab = lrint_optab;
2797       break;
2798
2799     CASE_FLT_FN (BUILT_IN_IROUND):
2800       fallback_fn = BUILT_IN_LROUND;
2801       /* FALLTHRU */
2802     CASE_FLT_FN (BUILT_IN_LROUND):
2803     CASE_FLT_FN (BUILT_IN_LLROUND):
2804       builtin_optab = lround_optab;
2805       break;
2806
2807     default:
2808       gcc_unreachable ();
2809     }
2810
2811   /* There's no easy way to detect the case we need to set EDOM.  */
2812   if (flag_errno_math && fallback_fn == BUILT_IN_NONE)
2813     return NULL_RTX;
2814
2815   /* Make a suitable register to place result in.  */
2816   mode = TYPE_MODE (TREE_TYPE (exp));
2817
2818   /* There's no easy way to detect the case we need to set EDOM.  */
2819   if (!flag_errno_math)
2820     {
2821       target = gen_reg_rtx (mode);
2822
2823       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2824          need to expand the argument again.  This way, we will not perform
2825          side-effects more the once.  */
2826       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2827
2828       op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2829
2830       start_sequence ();
2831
2832       if (expand_sfix_optab (target, op0, builtin_optab))
2833         {
2834           /* Output the entire sequence.  */
2835           insns = get_insns ();
2836           end_sequence ();
2837           emit_insn (insns);
2838           return target;
2839         }
2840
2841       /* If we were unable to expand via the builtin, stop the sequence
2842          (without outputting the insns) and call to the library function
2843          with the stabilized argument list.  */
2844       end_sequence ();
2845     }
2846
2847   if (fallback_fn != BUILT_IN_NONE)
2848     {
2849       /* Fall back to rounding to long int.  Use implicit_p 0 - for non-C99
2850          targets, (int) round (x) should never be transformed into
2851          BUILT_IN_IROUND and if __builtin_iround is called directly, emit
2852          a call to lround in the hope that the target provides at least some
2853          C99 functions.  This should result in the best user experience for
2854          not full C99 targets.  */
2855       tree fallback_fndecl = mathfn_built_in_1 (TREE_TYPE (arg),
2856                                                 fallback_fn, 0);
2857
2858       exp = build_call_nofold_loc (EXPR_LOCATION (exp),
2859                                    fallback_fndecl, 1, arg);
2860
2861       target = expand_call (exp, NULL_RTX, target == const0_rtx);
2862       return convert_to_mode (mode, target, 0);
2863     }
2864
2865   target = expand_call (exp, target, target == const0_rtx);
2866
2867   return target;
2868 }
2869
2870 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
2871    a normal call should be emitted rather than expanding the function
2872    in-line.  EXP is the expression that is a call to the builtin
2873    function; if convenient, the result should be placed in TARGET.  */
2874
2875 static rtx
2876 expand_builtin_powi (tree exp, rtx target)
2877 {
2878   tree arg0, arg1;
2879   rtx op0, op1;
2880   enum machine_mode mode;
2881   enum machine_mode mode2;
2882
2883   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
2884     return NULL_RTX;
2885
2886   arg0 = CALL_EXPR_ARG (exp, 0);
2887   arg1 = CALL_EXPR_ARG (exp, 1);
2888   mode = TYPE_MODE (TREE_TYPE (exp));
2889
2890   /* Emit a libcall to libgcc.  */
2891
2892   /* Mode of the 2nd argument must match that of an int.  */
2893   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
2894
2895   if (target == NULL_RTX)
2896     target = gen_reg_rtx (mode);
2897
2898   op0 = expand_expr (arg0, NULL_RTX, mode, EXPAND_NORMAL);
2899   if (GET_MODE (op0) != mode)
2900     op0 = convert_to_mode (mode, op0, 0);
2901   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
2902   if (GET_MODE (op1) != mode2)
2903     op1 = convert_to_mode (mode2, op1, 0);
2904
2905   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
2906                                     target, LCT_CONST, mode, 2,
2907                                     op0, mode, op1, mode2);
2908
2909   return target;
2910 }
2911
2912 /* Expand expression EXP which is a call to the strlen builtin.  Return
2913    NULL_RTX if we failed the caller should emit a normal call, otherwise
2914    try to get the result in TARGET, if convenient.  */
2915
2916 static rtx
2917 expand_builtin_strlen (tree exp, rtx target,
2918                        enum machine_mode target_mode)
2919 {
2920   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
2921     return NULL_RTX;
2922   else
2923     {
2924       struct expand_operand ops[4];
2925       rtx pat;
2926       tree len;
2927       tree src = CALL_EXPR_ARG (exp, 0);
2928       rtx src_reg, before_strlen;
2929       enum machine_mode insn_mode = target_mode;
2930       enum insn_code icode = CODE_FOR_nothing;
2931       unsigned int align;
2932
2933       /* If the length can be computed at compile-time, return it.  */
2934       len = c_strlen (src, 0);
2935       if (len)
2936         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2937
2938       /* If the length can be computed at compile-time and is constant
2939          integer, but there are side-effects in src, evaluate
2940          src for side-effects, then return len.
2941          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2942          can be optimized into: i++; x = 3;  */
2943       len = c_strlen (src, 1);
2944       if (len && TREE_CODE (len) == INTEGER_CST)
2945         {
2946           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2947           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2948         }
2949
2950       align = get_pointer_alignment (src) / BITS_PER_UNIT;
2951
2952       /* If SRC is not a pointer type, don't do this operation inline.  */
2953       if (align == 0)
2954         return NULL_RTX;
2955
2956       /* Bail out if we can't compute strlen in the right mode.  */
2957       while (insn_mode != VOIDmode)
2958         {
2959           icode = optab_handler (strlen_optab, insn_mode);
2960           if (icode != CODE_FOR_nothing)
2961             break;
2962
2963           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
2964         }
2965       if (insn_mode == VOIDmode)
2966         return NULL_RTX;
2967
2968       /* Make a place to hold the source address.  We will not expand
2969          the actual source until we are sure that the expansion will
2970          not fail -- there are trees that cannot be expanded twice.  */
2971       src_reg = gen_reg_rtx (Pmode);
2972
2973       /* Mark the beginning of the strlen sequence so we can emit the
2974          source operand later.  */
2975       before_strlen = get_last_insn ();
2976
2977       create_output_operand (&ops[0], target, insn_mode);
2978       create_fixed_operand (&ops[1], gen_rtx_MEM (BLKmode, src_reg));
2979       create_integer_operand (&ops[2], 0);
2980       create_integer_operand (&ops[3], align);
2981       if (!maybe_expand_insn (icode, 4, ops))
2982         return NULL_RTX;
2983
2984       /* Now that we are assured of success, expand the source.  */
2985       start_sequence ();
2986       pat = expand_expr (src, src_reg, Pmode, EXPAND_NORMAL);
2987       if (pat != src_reg)
2988         {
2989 #ifdef POINTERS_EXTEND_UNSIGNED
2990           if (GET_MODE (pat) != Pmode)
2991             pat = convert_to_mode (Pmode, pat,
2992                                    POINTERS_EXTEND_UNSIGNED);
2993 #endif
2994           emit_move_insn (src_reg, pat);
2995         }
2996       pat = get_insns ();
2997       end_sequence ();
2998
2999       if (before_strlen)
3000         emit_insn_after (pat, before_strlen);
3001       else
3002         emit_insn_before (pat, get_insns ());
3003
3004       /* Return the value in the proper mode for this function.  */
3005       if (GET_MODE (ops[0].value) == target_mode)
3006         target = ops[0].value;
3007       else if (target != 0)
3008         convert_move (target, ops[0].value, 0);
3009       else
3010         target = convert_to_mode (target_mode, ops[0].value, 0);
3011
3012       return target;
3013     }
3014 }
3015
3016 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3017    bytes from constant string DATA + OFFSET and return it as target
3018    constant.  */
3019
3020 static rtx
3021 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
3022                          enum machine_mode mode)
3023 {
3024   const char *str = (const char *) data;
3025
3026   gcc_assert (offset >= 0
3027               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
3028                   <= strlen (str) + 1));
3029
3030   return c_readstr (str + offset, mode);
3031 }
3032
3033 /* Expand a call EXP to the memcpy builtin.
3034    Return NULL_RTX if we failed, the caller should emit a normal call,
3035    otherwise try to get the result in TARGET, if convenient (and in
3036    mode MODE if that's convenient).  */
3037
3038 static rtx
3039 expand_builtin_memcpy (tree exp, rtx target)
3040 {
3041   if (!validate_arglist (exp,
3042                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3043     return NULL_RTX;
3044   else
3045     {
3046       tree dest = CALL_EXPR_ARG (exp, 0);
3047       tree src = CALL_EXPR_ARG (exp, 1);
3048       tree len = CALL_EXPR_ARG (exp, 2);
3049       const char *src_str;
3050       unsigned int src_align = get_pointer_alignment (src);
3051       unsigned int dest_align = get_pointer_alignment (dest);
3052       rtx dest_mem, src_mem, dest_addr, len_rtx;
3053       HOST_WIDE_INT expected_size = -1;
3054       unsigned int expected_align = 0;
3055
3056       /* If DEST is not a pointer type, call the normal function.  */
3057       if (dest_align == 0)
3058         return NULL_RTX;
3059
3060       /* If either SRC is not a pointer type, don't do this
3061          operation in-line.  */
3062       if (src_align == 0)
3063         return NULL_RTX;
3064
3065       if (currently_expanding_gimple_stmt)
3066         stringop_block_profile (currently_expanding_gimple_stmt,
3067                                 &expected_align, &expected_size);
3068
3069       if (expected_align < dest_align)
3070         expected_align = dest_align;
3071       dest_mem = get_memory_rtx (dest, len);
3072       set_mem_align (dest_mem, dest_align);
3073       len_rtx = expand_normal (len);
3074       src_str = c_getstr (src);
3075
3076       /* If SRC is a string constant and block move would be done
3077          by pieces, we can avoid loading the string from memory
3078          and only stored the computed constants.  */
3079       if (src_str
3080           && CONST_INT_P (len_rtx)
3081           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3082           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3083                                   CONST_CAST (char *, src_str),
3084                                   dest_align, false))
3085         {
3086           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3087                                       builtin_memcpy_read_str,
3088                                       CONST_CAST (char *, src_str),
3089                                       dest_align, false, 0);
3090           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3091           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3092           return dest_mem;
3093         }
3094
3095       src_mem = get_memory_rtx (src, len);
3096       set_mem_align (src_mem, src_align);
3097
3098       /* Copy word part most expediently.  */
3099       dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
3100                                          CALL_EXPR_TAILCALL (exp)
3101                                          ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3102                                          expected_align, expected_size);
3103
3104       if (dest_addr == 0)
3105         {
3106           dest_addr = force_operand (XEXP (dest_mem, 0), target);
3107           dest_addr = convert_memory_address (ptr_mode, dest_addr);
3108         }
3109       return dest_addr;
3110     }
3111 }
3112
3113 /* Expand a call EXP to the mempcpy builtin.
3114    Return NULL_RTX if we failed; the caller should emit a normal call,
3115    otherwise try to get the result in TARGET, if convenient (and in
3116    mode MODE if that's convenient).  If ENDP is 0 return the
3117    destination pointer, if ENDP is 1 return the end pointer ala
3118    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3119    stpcpy.  */
3120
3121 static rtx
3122 expand_builtin_mempcpy (tree exp, rtx target, enum machine_mode mode)
3123 {
3124   if (!validate_arglist (exp,
3125                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3126     return NULL_RTX;
3127   else
3128     {
3129       tree dest = CALL_EXPR_ARG (exp, 0);
3130       tree src = CALL_EXPR_ARG (exp, 1);
3131       tree len = CALL_EXPR_ARG (exp, 2);
3132       return expand_builtin_mempcpy_args (dest, src, len,
3133                                           target, mode, /*endp=*/ 1);
3134     }
3135 }
3136
3137 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3138    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3139    so that this can also be called without constructing an actual CALL_EXPR.
3140    The other arguments and return value are the same as for
3141    expand_builtin_mempcpy.  */
3142
3143 static rtx
3144 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3145                              rtx target, enum machine_mode mode, int endp)
3146 {
3147     /* If return value is ignored, transform mempcpy into memcpy.  */
3148   if (target == const0_rtx && builtin_decl_implicit_p (BUILT_IN_MEMCPY))
3149     {
3150       tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
3151       tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3152                                            dest, src, len);
3153       return expand_expr (result, target, mode, EXPAND_NORMAL);
3154     }
3155   else
3156     {
3157       const char *src_str;
3158       unsigned int src_align = get_pointer_alignment (src);
3159       unsigned int dest_align = get_pointer_alignment (dest);
3160       rtx dest_mem, src_mem, len_rtx;
3161
3162       /* If either SRC or DEST is not a pointer type, don't do this
3163          operation in-line.  */
3164       if (dest_align == 0 || src_align == 0)
3165         return NULL_RTX;
3166
3167       /* If LEN is not constant, call the normal function.  */
3168       if (! host_integerp (len, 1))
3169         return NULL_RTX;
3170
3171       len_rtx = expand_normal (len);
3172       src_str = c_getstr (src);
3173
3174       /* If SRC is a string constant and block move would be done
3175          by pieces, we can avoid loading the string from memory
3176          and only stored the computed constants.  */
3177       if (src_str
3178           && CONST_INT_P (len_rtx)
3179           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3180           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3181                                   CONST_CAST (char *, src_str),
3182                                   dest_align, false))
3183         {
3184           dest_mem = get_memory_rtx (dest, len);
3185           set_mem_align (dest_mem, dest_align);
3186           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3187                                       builtin_memcpy_read_str,
3188                                       CONST_CAST (char *, src_str),
3189                                       dest_align, false, endp);
3190           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3191           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3192           return dest_mem;
3193         }
3194
3195       if (CONST_INT_P (len_rtx)
3196           && can_move_by_pieces (INTVAL (len_rtx),
3197                                  MIN (dest_align, src_align)))
3198         {
3199           dest_mem = get_memory_rtx (dest, len);
3200           set_mem_align (dest_mem, dest_align);
3201           src_mem = get_memory_rtx (src, len);
3202           set_mem_align (src_mem, src_align);
3203           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3204                                      MIN (dest_align, src_align), endp);
3205           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3206           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3207           return dest_mem;
3208         }
3209
3210       return NULL_RTX;
3211     }
3212 }
3213
3214 #ifndef HAVE_movstr
3215 # define HAVE_movstr 0
3216 # define CODE_FOR_movstr CODE_FOR_nothing
3217 #endif
3218
3219 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3220    we failed, the caller should emit a normal call, otherwise try to
3221    get the result in TARGET, if convenient.  If ENDP is 0 return the
3222    destination pointer, if ENDP is 1 return the end pointer ala
3223    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3224    stpcpy.  */
3225
3226 static rtx
3227 expand_movstr (tree dest, tree src, rtx target, int endp)
3228 {
3229   struct expand_operand ops[3];
3230   rtx dest_mem;
3231   rtx src_mem;
3232
3233   if (!HAVE_movstr)
3234     return NULL_RTX;
3235
3236   dest_mem = get_memory_rtx (dest, NULL);
3237   src_mem = get_memory_rtx (src, NULL);
3238   if (!endp)
3239     {
3240       target = force_reg (Pmode, XEXP (dest_mem, 0));
3241       dest_mem = replace_equiv_address (dest_mem, target);
3242     }
3243
3244   create_output_operand (&ops[0], endp ? target : NULL_RTX, Pmode);
3245   create_fixed_operand (&ops[1], dest_mem);
3246   create_fixed_operand (&ops[2], src_mem);
3247   expand_insn (CODE_FOR_movstr, 3, ops);
3248
3249   if (endp && target != const0_rtx)
3250     {
3251       target = ops[0].value;
3252       /* movstr is supposed to set end to the address of the NUL
3253          terminator.  If the caller requested a mempcpy-like return value,
3254          adjust it.  */
3255       if (endp == 1)
3256         {
3257           rtx tem = plus_constant (GET_MODE (target),
3258                                    gen_lowpart (GET_MODE (target), target), 1);
3259           emit_move_insn (target, force_operand (tem, NULL_RTX));
3260         }
3261     }
3262   return target;
3263 }
3264
3265 /* Expand expression EXP, which is a call to the strcpy builtin.  Return
3266    NULL_RTX if we failed the caller should emit a normal call, otherwise
3267    try to get the result in TARGET, if convenient (and in mode MODE if that's
3268    convenient).  */
3269
3270 static rtx
3271 expand_builtin_strcpy (tree exp, rtx target)
3272 {
3273   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3274    {
3275      tree dest = CALL_EXPR_ARG (exp, 0);
3276      tree src = CALL_EXPR_ARG (exp, 1);
3277      return expand_builtin_strcpy_args (dest, src, target);
3278    }
3279    return NULL_RTX;
3280 }
3281
3282 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3283    arguments to the builtin_strcpy call DEST and SRC are broken out
3284    so that this can also be called without constructing an actual CALL_EXPR.
3285    The other arguments and return value are the same as for
3286    expand_builtin_strcpy.  */
3287
3288 static rtx
3289 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3290 {
3291   return expand_movstr (dest, src, target, /*endp=*/0);
3292 }
3293
3294 /* Expand a call EXP to the stpcpy builtin.
3295    Return NULL_RTX if we failed the caller should emit a normal call,
3296    otherwise try to get the result in TARGET, if convenient (and in
3297    mode MODE if that's convenient).  */
3298
3299 static rtx
3300 expand_builtin_stpcpy (tree exp, rtx target, enum machine_mode mode)
3301 {
3302   tree dst, src;
3303   location_t loc = EXPR_LOCATION (exp);
3304
3305   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3306     return NULL_RTX;
3307
3308   dst = CALL_EXPR_ARG (exp, 0);
3309   src = CALL_EXPR_ARG (exp, 1);
3310
3311   /* If return value is ignored, transform stpcpy into strcpy.  */
3312   if (target == const0_rtx && builtin_decl_implicit (BUILT_IN_STRCPY))
3313     {
3314       tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
3315       tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3316       return expand_expr (result, target, mode, EXPAND_NORMAL);
3317     }
3318   else
3319     {
3320       tree len, lenp1;
3321       rtx ret;
3322
3323       /* Ensure we get an actual string whose length can be evaluated at
3324          compile-time, not an expression containing a string.  This is
3325          because the latter will potentially produce pessimized code
3326          when used to produce the return value.  */
3327       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3328         return expand_movstr (dst, src, target, /*endp=*/2);
3329
3330       lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3331       ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3332                                          target, mode, /*endp=*/2);
3333
3334       if (ret)
3335         return ret;
3336
3337       if (TREE_CODE (len) == INTEGER_CST)
3338         {
3339           rtx len_rtx = expand_normal (len);
3340
3341           if (CONST_INT_P (len_rtx))
3342             {
3343               ret = expand_builtin_strcpy_args (dst, src, target);
3344
3345               if (ret)
3346                 {
3347                   if (! target)
3348                     {
3349                       if (mode != VOIDmode)
3350                         target = gen_reg_rtx (mode);
3351                       else
3352                         target = gen_reg_rtx (GET_MODE (ret));
3353                     }
3354                   if (GET_MODE (target) != GET_MODE (ret))
3355                     ret = gen_lowpart (GET_MODE (target), ret);
3356
3357                   ret = plus_constant (GET_MODE (ret), ret, INTVAL (len_rtx));
3358                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3359                   gcc_assert (ret);
3360
3361                   return target;
3362                 }
3363             }
3364         }
3365
3366       return expand_movstr (dst, src, target, /*endp=*/2);
3367     }
3368 }
3369
3370 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3371    bytes from constant string DATA + OFFSET and return it as target
3372    constant.  */
3373
3374 rtx
3375 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3376                           enum machine_mode mode)
3377 {
3378   const char *str = (const char *) data;
3379
3380   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3381     return const0_rtx;
3382
3383   return c_readstr (str + offset, mode);
3384 }
3385
3386 /* Expand expression EXP, which is a call to the strncpy builtin.  Return
3387    NULL_RTX if we failed the caller should emit a normal call.  */
3388
3389 static rtx
3390 expand_builtin_strncpy (tree exp, rtx target)
3391 {
3392   location_t loc = EXPR_LOCATION (exp);
3393
3394   if (validate_arglist (exp,
3395                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3396     {
3397       tree dest = CALL_EXPR_ARG (exp, 0);
3398       tree src = CALL_EXPR_ARG (exp, 1);
3399       tree len = CALL_EXPR_ARG (exp, 2);
3400       tree slen = c_strlen (src, 1);
3401
3402       /* We must be passed a constant len and src parameter.  */
3403       if (!host_integerp (len, 1) || !slen || !host_integerp (slen, 1))
3404         return NULL_RTX;
3405
3406       slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3407
3408       /* We're required to pad with trailing zeros if the requested
3409          len is greater than strlen(s2)+1.  In that case try to
3410          use store_by_pieces, if it fails, punt.  */
3411       if (tree_int_cst_lt (slen, len))
3412         {
3413           unsigned int dest_align = get_pointer_alignment (dest);
3414           const char *p = c_getstr (src);
3415           rtx dest_mem;
3416
3417           if (!p || dest_align == 0 || !host_integerp (len, 1)
3418               || !can_store_by_pieces (tree_low_cst (len, 1),
3419                                        builtin_strncpy_read_str,
3420                                        CONST_CAST (char *, p),
3421                                        dest_align, false))
3422             return NULL_RTX;
3423
3424           dest_mem = get_memory_rtx (dest, len);
3425           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3426                            builtin_strncpy_read_str,
3427                            CONST_CAST (char *, p), dest_align, false, 0);
3428           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3429           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3430           return dest_mem;
3431         }
3432     }
3433   return NULL_RTX;
3434 }
3435
3436 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3437    bytes from constant string DATA + OFFSET and return it as target
3438    constant.  */
3439
3440 rtx
3441 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3442                          enum machine_mode mode)
3443 {
3444   const char *c = (const char *) data;
3445   char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3446
3447   memset (p, *c, GET_MODE_SIZE (mode));
3448
3449   return c_readstr (p, mode);
3450 }
3451
3452 /* Callback routine for store_by_pieces.  Return the RTL of a register
3453    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3454    char value given in the RTL register data.  For example, if mode is
3455    4 bytes wide, return the RTL for 0x01010101*data.  */
3456
3457 static rtx
3458 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3459                         enum machine_mode mode)
3460 {
3461   rtx target, coeff;
3462   size_t size;
3463   char *p;
3464
3465   size = GET_MODE_SIZE (mode);
3466   if (size == 1)
3467     return (rtx) data;
3468
3469   p = XALLOCAVEC (char, size);
3470   memset (p, 1, size);
3471   coeff = c_readstr (p, mode);
3472
3473   target = convert_to_mode (mode, (rtx) data, 1);
3474   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3475   return force_reg (mode, target);
3476 }
3477
3478 /* Expand expression EXP, which is a call to the memset builtin.  Return
3479    NULL_RTX if we failed the caller should emit a normal call, otherwise
3480    try to get the result in TARGET, if convenient (and in mode MODE if that's
3481    convenient).  */
3482
3483 static rtx
3484 expand_builtin_memset (tree exp, rtx target, enum machine_mode mode)
3485 {
3486   if (!validate_arglist (exp,
3487                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3488     return NULL_RTX;
3489   else
3490     {
3491       tree dest = CALL_EXPR_ARG (exp, 0);
3492       tree val = CALL_EXPR_ARG (exp, 1);
3493       tree len = CALL_EXPR_ARG (exp, 2);
3494       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3495     }
3496 }
3497
3498 /* Helper function to do the actual work for expand_builtin_memset.  The
3499    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3500    so that this can also be called without constructing an actual CALL_EXPR.
3501    The other arguments and return value are the same as for
3502    expand_builtin_memset.  */
3503
3504 static rtx
3505 expand_builtin_memset_args (tree dest, tree val, tree len,
3506                             rtx target, enum machine_mode mode, tree orig_exp)
3507 {
3508   tree fndecl, fn;
3509   enum built_in_function fcode;
3510   enum machine_mode val_mode;
3511   char c;
3512   unsigned int dest_align;
3513   rtx dest_mem, dest_addr, len_rtx;
3514   HOST_WIDE_INT expected_size = -1;
3515   unsigned int expected_align = 0;
3516
3517   dest_align = get_pointer_alignment (dest);
3518
3519   /* If DEST is not a pointer type, don't do this operation in-line.  */
3520   if (dest_align == 0)
3521     return NULL_RTX;
3522
3523   if (currently_expanding_gimple_stmt)
3524     stringop_block_profile (currently_expanding_gimple_stmt,
3525                             &expected_align, &expected_size);
3526
3527   if (expected_align < dest_align)
3528     expected_align = dest_align;
3529
3530   /* If the LEN parameter is zero, return DEST.  */
3531   if (integer_zerop (len))
3532     {
3533       /* Evaluate and ignore VAL in case it has side-effects.  */
3534       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3535       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3536     }
3537
3538   /* Stabilize the arguments in case we fail.  */
3539   dest = builtin_save_expr (dest);
3540   val = builtin_save_expr (val);
3541   len = builtin_save_expr (len);
3542
3543   len_rtx = expand_normal (len);
3544   dest_mem = get_memory_rtx (dest, len);
3545   val_mode = TYPE_MODE (unsigned_char_type_node);
3546
3547   if (TREE_CODE (val) != INTEGER_CST)
3548     {
3549       rtx val_rtx;
3550
3551       val_rtx = expand_normal (val);
3552       val_rtx = convert_to_mode (val_mode, val_rtx, 0);
3553
3554       /* Assume that we can memset by pieces if we can store
3555        * the coefficients by pieces (in the required modes).
3556        * We can't pass builtin_memset_gen_str as that emits RTL.  */
3557       c = 1;
3558       if (host_integerp (len, 1)
3559           && can_store_by_pieces (tree_low_cst (len, 1),
3560                                   builtin_memset_read_str, &c, dest_align,
3561                                   true))
3562         {
3563           val_rtx = force_reg (val_mode, val_rtx);
3564           store_by_pieces (dest_mem, tree_low_cst (len, 1),
3565                            builtin_memset_gen_str, val_rtx, dest_align,
3566                            true, 0);
3567         }
3568       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3569                                         dest_align, expected_align,
3570                                         expected_size))
3571         goto do_libcall;
3572
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   if (target_char_cast (val, &c))
3579     goto do_libcall;
3580
3581   if (c)
3582     {
3583       if (host_integerp (len, 1)
3584           && can_store_by_pieces (tree_low_cst (len, 1),
3585                                   builtin_memset_read_str, &c, dest_align,
3586                                   true))
3587         store_by_pieces (dest_mem, tree_low_cst (len, 1),
3588                          builtin_memset_read_str, &c, dest_align, true, 0);
3589       else if (!set_storage_via_setmem (dest_mem, len_rtx,
3590                                         gen_int_mode (c, val_mode),
3591                                         dest_align, expected_align,
3592                                         expected_size))
3593         goto do_libcall;
3594
3595       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3596       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3597       return dest_mem;
3598     }
3599
3600   set_mem_align (dest_mem, dest_align);
3601   dest_addr = clear_storage_hints (dest_mem, len_rtx,
3602                                    CALL_EXPR_TAILCALL (orig_exp)
3603                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3604                                    expected_align, expected_size);
3605
3606   if (dest_addr == 0)
3607     {
3608       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3609       dest_addr = convert_memory_address (ptr_mode, dest_addr);
3610     }
3611
3612   return dest_addr;
3613
3614  do_libcall:
3615   fndecl = get_callee_fndecl (orig_exp);
3616   fcode = DECL_FUNCTION_CODE (fndecl);
3617   if (fcode == BUILT_IN_MEMSET)
3618     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
3619                                 dest, val, len);
3620   else if (fcode == BUILT_IN_BZERO)
3621     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
3622                                 dest, len);
3623   else
3624     gcc_unreachable ();
3625   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3626   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3627   return expand_call (fn, target, target == const0_rtx);
3628 }
3629
3630 /* Expand expression EXP, which is a call to the bzero builtin.  Return
3631    NULL_RTX if we failed the caller should emit a normal call.  */
3632
3633 static rtx
3634 expand_builtin_bzero (tree exp)
3635 {
3636   tree dest, size;
3637   location_t loc = EXPR_LOCATION (exp);
3638
3639   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3640     return NULL_RTX;
3641
3642   dest = CALL_EXPR_ARG (exp, 0);
3643   size = CALL_EXPR_ARG (exp, 1);
3644
3645   /* New argument list transforming bzero(ptr x, int y) to
3646      memset(ptr x, int 0, size_t y).   This is done this way
3647      so that if it isn't expanded inline, we fallback to
3648      calling bzero instead of memset.  */
3649
3650   return expand_builtin_memset_args (dest, integer_zero_node,
3651                                      fold_convert_loc (loc,
3652                                                        size_type_node, size),
3653                                      const0_rtx, VOIDmode, exp);
3654 }
3655
3656 /* Expand expression EXP, which is a call to the memcmp built-in function.
3657    Return NULL_RTX if we failed and the caller should emit a normal call,
3658    otherwise try to get the result in TARGET, if convenient (and in mode
3659    MODE, if that's convenient).  */
3660
3661 static rtx
3662 expand_builtin_memcmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3663                        ATTRIBUTE_UNUSED enum machine_mode mode)
3664 {
3665   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
3666
3667   if (!validate_arglist (exp,
3668                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3669     return NULL_RTX;
3670
3671   /* Note: The cmpstrnsi pattern, if it exists, is not suitable for
3672      implementing memcmp because it will stop if it encounters two
3673      zero bytes.  */
3674 #if defined HAVE_cmpmemsi
3675   {
3676     rtx arg1_rtx, arg2_rtx, arg3_rtx;
3677     rtx result;
3678     rtx insn;
3679     tree arg1 = CALL_EXPR_ARG (exp, 0);
3680     tree arg2 = CALL_EXPR_ARG (exp, 1);
3681     tree len = CALL_EXPR_ARG (exp, 2);
3682
3683     unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3684     unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3685     enum machine_mode insn_mode;
3686
3687     if (HAVE_cmpmemsi)
3688       insn_mode = insn_data[(int) CODE_FOR_cmpmemsi].operand[0].mode;
3689     else
3690       return NULL_RTX;
3691
3692     /* If we don't have POINTER_TYPE, call the function.  */
3693     if (arg1_align == 0 || arg2_align == 0)
3694       return NULL_RTX;
3695
3696     /* Make a place to write the result of the instruction.  */
3697     result = target;
3698     if (! (result != 0
3699            && REG_P (result) && GET_MODE (result) == insn_mode
3700            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3701       result = gen_reg_rtx (insn_mode);
3702
3703     arg1_rtx = get_memory_rtx (arg1, len);
3704     arg2_rtx = get_memory_rtx (arg2, len);
3705     arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
3706
3707     /* Set MEM_SIZE as appropriate.  */
3708     if (CONST_INT_P (arg3_rtx))
3709       {
3710         set_mem_size (arg1_rtx, INTVAL (arg3_rtx));
3711         set_mem_size (arg2_rtx, INTVAL (arg3_rtx));
3712       }
3713
3714     if (HAVE_cmpmemsi)
3715       insn = gen_cmpmemsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3716                            GEN_INT (MIN (arg1_align, arg2_align)));
3717     else
3718       gcc_unreachable ();
3719
3720     if (insn)
3721       emit_insn (insn);
3722     else
3723       emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
3724                                TYPE_MODE (integer_type_node), 3,
3725                                XEXP (arg1_rtx, 0), Pmode,
3726                                XEXP (arg2_rtx, 0), Pmode,
3727                                convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3728                                                 TYPE_UNSIGNED (sizetype)),
3729                                TYPE_MODE (sizetype));
3730
3731     /* Return the value in the proper mode for this function.  */
3732     mode = TYPE_MODE (TREE_TYPE (exp));
3733     if (GET_MODE (result) == mode)
3734       return result;
3735     else if (target != 0)
3736       {
3737         convert_move (target, result, 0);
3738         return target;
3739       }
3740     else
3741       return convert_to_mode (mode, result, 0);
3742   }
3743 #endif /* HAVE_cmpmemsi.  */
3744
3745   return NULL_RTX;
3746 }
3747
3748 /* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
3749    if we failed the caller should emit a normal call, otherwise try to get
3750    the result in TARGET, if convenient.  */
3751
3752 static rtx
3753 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
3754 {
3755   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3756     return NULL_RTX;
3757
3758 #if defined HAVE_cmpstrsi || defined HAVE_cmpstrnsi
3759   if (direct_optab_handler (cmpstr_optab, SImode) != CODE_FOR_nothing
3760       || direct_optab_handler (cmpstrn_optab, SImode) != CODE_FOR_nothing)
3761     {
3762       rtx arg1_rtx, arg2_rtx;
3763       rtx result, insn = NULL_RTX;
3764       tree fndecl, fn;
3765       tree arg1 = CALL_EXPR_ARG (exp, 0);
3766       tree arg2 = CALL_EXPR_ARG (exp, 1);
3767
3768       unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3769       unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3770
3771       /* If we don't have POINTER_TYPE, call the function.  */
3772       if (arg1_align == 0 || arg2_align == 0)
3773         return NULL_RTX;
3774
3775       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
3776       arg1 = builtin_save_expr (arg1);
3777       arg2 = builtin_save_expr (arg2);
3778
3779       arg1_rtx = get_memory_rtx (arg1, NULL);
3780       arg2_rtx = get_memory_rtx (arg2, NULL);
3781
3782 #ifdef HAVE_cmpstrsi
3783       /* Try to call cmpstrsi.  */
3784       if (HAVE_cmpstrsi)
3785         {
3786           enum machine_mode insn_mode
3787             = insn_data[(int) CODE_FOR_cmpstrsi].operand[0].mode;
3788
3789           /* Make a place to write the result of the instruction.  */
3790           result = target;
3791           if (! (result != 0
3792                  && REG_P (result) && GET_MODE (result) == insn_mode
3793                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3794             result = gen_reg_rtx (insn_mode);
3795
3796           insn = gen_cmpstrsi (result, arg1_rtx, arg2_rtx,
3797                                GEN_INT (MIN (arg1_align, arg2_align)));
3798         }
3799 #endif
3800 #ifdef HAVE_cmpstrnsi
3801       /* Try to determine at least one length and call cmpstrnsi.  */
3802       if (!insn && HAVE_cmpstrnsi)
3803         {
3804           tree len;
3805           rtx arg3_rtx;
3806
3807           enum machine_mode insn_mode
3808             = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3809           tree len1 = c_strlen (arg1, 1);
3810           tree len2 = c_strlen (arg2, 1);
3811
3812           if (len1)
3813             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3814           if (len2)
3815             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3816
3817           /* If we don't have a constant length for the first, use the length
3818              of the second, if we know it.  We don't require a constant for
3819              this case; some cost analysis could be done if both are available
3820              but neither is constant.  For now, assume they're equally cheap,
3821              unless one has side effects.  If both strings have constant lengths,
3822              use the smaller.  */
3823
3824           if (!len1)
3825             len = len2;
3826           else if (!len2)
3827             len = len1;
3828           else if (TREE_SIDE_EFFECTS (len1))
3829             len = len2;
3830           else if (TREE_SIDE_EFFECTS (len2))
3831             len = len1;
3832           else if (TREE_CODE (len1) != INTEGER_CST)
3833             len = len2;
3834           else if (TREE_CODE (len2) != INTEGER_CST)
3835             len = len1;
3836           else if (tree_int_cst_lt (len1, len2))
3837             len = len1;
3838           else
3839             len = len2;
3840
3841           /* If both arguments have side effects, we cannot optimize.  */
3842           if (!len || TREE_SIDE_EFFECTS (len))
3843             goto do_libcall;
3844
3845           arg3_rtx = expand_normal (len);
3846
3847           /* Make a place to write the result of the instruction.  */
3848           result = target;
3849           if (! (result != 0
3850                  && REG_P (result) && GET_MODE (result) == insn_mode
3851                  && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3852             result = gen_reg_rtx (insn_mode);
3853
3854           insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3855                                 GEN_INT (MIN (arg1_align, arg2_align)));
3856         }
3857 #endif
3858
3859       if (insn)
3860         {
3861           enum machine_mode mode;
3862           emit_insn (insn);
3863
3864           /* Return the value in the proper mode for this function.  */
3865           mode = TYPE_MODE (TREE_TYPE (exp));
3866           if (GET_MODE (result) == mode)
3867             return result;
3868           if (target == 0)
3869             return convert_to_mode (mode, result, 0);
3870           convert_move (target, result, 0);
3871           return target;
3872         }
3873
3874       /* Expand the library call ourselves using a stabilized argument
3875          list to avoid re-evaluating the function's arguments twice.  */
3876 #ifdef HAVE_cmpstrnsi
3877     do_libcall:
3878 #endif
3879       fndecl = get_callee_fndecl (exp);
3880       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
3881       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3882       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
3883       return expand_call (fn, target, target == const0_rtx);
3884     }
3885 #endif
3886   return NULL_RTX;
3887 }
3888
3889 /* Expand expression EXP, which is a call to the strncmp builtin. Return
3890    NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
3891    the result in TARGET, if convenient.  */
3892
3893 static rtx
3894 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3895                         ATTRIBUTE_UNUSED enum machine_mode mode)
3896 {
3897   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
3898
3899   if (!validate_arglist (exp,
3900                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3901     return NULL_RTX;
3902
3903   /* If c_strlen can determine an expression for one of the string
3904      lengths, and it doesn't have side effects, then emit cmpstrnsi
3905      using length MIN(strlen(string)+1, arg3).  */
3906 #ifdef HAVE_cmpstrnsi
3907   if (HAVE_cmpstrnsi)
3908   {
3909     tree len, len1, len2;
3910     rtx arg1_rtx, arg2_rtx, arg3_rtx;
3911     rtx result, insn;
3912     tree fndecl, fn;
3913     tree arg1 = CALL_EXPR_ARG (exp, 0);
3914     tree arg2 = CALL_EXPR_ARG (exp, 1);
3915     tree arg3 = CALL_EXPR_ARG (exp, 2);
3916
3917     unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3918     unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3919     enum machine_mode insn_mode
3920       = insn_data[(int) CODE_FOR_cmpstrnsi].operand[0].mode;
3921
3922     len1 = c_strlen (arg1, 1);
3923     len2 = c_strlen (arg2, 1);
3924
3925     if (len1)
3926       len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
3927     if (len2)
3928       len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
3929
3930     /* If we don't have a constant length for the first, use the length
3931        of the second, if we know it.  We don't require a constant for
3932        this case; some cost analysis could be done if both are available
3933        but neither is constant.  For now, assume they're equally cheap,
3934        unless one has side effects.  If both strings have constant lengths,
3935        use the smaller.  */
3936
3937     if (!len1)
3938       len = len2;
3939     else if (!len2)
3940       len = len1;
3941     else if (TREE_SIDE_EFFECTS (len1))
3942       len = len2;
3943     else if (TREE_SIDE_EFFECTS (len2))
3944       len = len1;
3945     else if (TREE_CODE (len1) != INTEGER_CST)
3946       len = len2;
3947     else if (TREE_CODE (len2) != INTEGER_CST)
3948       len = len1;
3949     else if (tree_int_cst_lt (len1, len2))
3950       len = len1;
3951     else
3952       len = len2;
3953
3954     /* If both arguments have side effects, we cannot optimize.  */
3955     if (!len || TREE_SIDE_EFFECTS (len))
3956       return NULL_RTX;
3957
3958     /* The actual new length parameter is MIN(len,arg3).  */
3959     len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
3960                        fold_convert_loc (loc, TREE_TYPE (len), arg3));
3961
3962     /* If we don't have POINTER_TYPE, call the function.  */
3963     if (arg1_align == 0 || arg2_align == 0)
3964       return NULL_RTX;
3965
3966     /* Make a place to write the result of the instruction.  */
3967     result = target;
3968     if (! (result != 0
3969            && REG_P (result) && GET_MODE (result) == insn_mode
3970            && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3971       result = gen_reg_rtx (insn_mode);
3972
3973     /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
3974     arg1 = builtin_save_expr (arg1);
3975     arg2 = builtin_save_expr (arg2);
3976     len = builtin_save_expr (len);
3977
3978     arg1_rtx = get_memory_rtx (arg1, len);
3979     arg2_rtx = get_memory_rtx (arg2, len);
3980     arg3_rtx = expand_normal (len);
3981     insn = gen_cmpstrnsi (result, arg1_rtx, arg2_rtx, arg3_rtx,
3982                           GEN_INT (MIN (arg1_align, arg2_align)));
3983     if (insn)
3984       {
3985         emit_insn (insn);
3986
3987         /* Return the value in the proper mode for this function.  */
3988         mode = TYPE_MODE (TREE_TYPE (exp));
3989         if (GET_MODE (result) == mode)
3990           return result;
3991         if (target == 0)
3992           return convert_to_mode (mode, result, 0);
3993         convert_move (target, result, 0);
3994         return target;
3995       }
3996
3997     /* Expand the library call ourselves using a stabilized argument
3998        list to avoid re-evaluating the function's arguments twice.  */
3999     fndecl = get_callee_fndecl (exp);
4000     fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
4001                                 arg1, arg2, len);
4002     gcc_assert (TREE_CODE (fn) == CALL_EXPR);
4003     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
4004     return expand_call (fn, target, target == const0_rtx);
4005   }
4006 #endif
4007   return NULL_RTX;
4008 }
4009
4010 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
4011    if that's convenient.  */
4012
4013 rtx
4014 expand_builtin_saveregs (void)
4015 {
4016   rtx val, seq;
4017
4018   /* Don't do __builtin_saveregs more than once in a function.
4019      Save the result of the first call and reuse it.  */
4020   if (saveregs_value != 0)
4021     return saveregs_value;
4022
4023   /* When this function is called, it means that registers must be
4024      saved on entry to this function.  So we migrate the call to the
4025      first insn of this function.  */
4026
4027   start_sequence ();
4028
4029   /* Do whatever the machine needs done in this case.  */
4030   val = targetm.calls.expand_builtin_saveregs ();
4031
4032   seq = get_insns ();
4033   end_sequence ();
4034
4035   saveregs_value = val;
4036
4037   /* Put the insns after the NOTE that starts the function.  If this
4038      is inside a start_sequence, make the outer-level insn chain current, so
4039      the code is placed at the start of the function.  */
4040   push_topmost_sequence ();
4041   emit_insn_after (seq, entry_of_function ());
4042   pop_topmost_sequence ();
4043
4044   return val;
4045 }
4046
4047 /* Expand a call to __builtin_next_arg.  */
4048
4049 static rtx
4050 expand_builtin_next_arg (void)
4051 {
4052   /* Checking arguments is already done in fold_builtin_next_arg
4053      that must be called before this function.  */
4054   return expand_binop (ptr_mode, add_optab,
4055                        crtl->args.internal_arg_pointer,
4056                        crtl->args.arg_offset_rtx,
4057                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
4058 }
4059
4060 /* Make it easier for the backends by protecting the valist argument
4061    from multiple evaluations.  */
4062
4063 static tree
4064 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4065 {
4066   tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4067
4068   /* The current way of determining the type of valist is completely
4069      bogus.  We should have the information on the va builtin instead.  */
4070   if (!vatype)
4071     vatype = targetm.fn_abi_va_list (cfun->decl);
4072
4073   if (TREE_CODE (vatype) == ARRAY_TYPE)
4074     {
4075       if (TREE_SIDE_EFFECTS (valist))
4076         valist = save_expr (valist);
4077
4078       /* For this case, the backends will be expecting a pointer to
4079          vatype, but it's possible we've actually been given an array
4080          (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4081          So fix it.  */
4082       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4083         {
4084           tree p1 = build_pointer_type (TREE_TYPE (vatype));
4085           valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4086         }
4087     }
4088   else
4089     {
4090       tree pt = build_pointer_type (vatype);
4091
4092       if (! needs_lvalue)
4093         {
4094           if (! TREE_SIDE_EFFECTS (valist))
4095             return valist;
4096
4097           valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4098           TREE_SIDE_EFFECTS (valist) = 1;
4099         }
4100
4101       if (TREE_SIDE_EFFECTS (valist))
4102         valist = save_expr (valist);
4103       valist = fold_build2_loc (loc, MEM_REF,
4104                                 vatype, valist, build_int_cst (pt, 0));
4105     }
4106
4107   return valist;
4108 }
4109
4110 /* The "standard" definition of va_list is void*.  */
4111
4112 tree
4113 std_build_builtin_va_list (void)
4114 {
4115   return ptr_type_node;
4116 }
4117
4118 /* The "standard" abi va_list is va_list_type_node.  */
4119
4120 tree
4121 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4122 {
4123   return va_list_type_node;
4124 }
4125
4126 /* The "standard" type of va_list is va_list_type_node.  */
4127
4128 tree
4129 std_canonical_va_list_type (tree type)
4130 {
4131   tree wtype, htype;
4132
4133   if (INDIRECT_REF_P (type))
4134     type = TREE_TYPE (type);
4135   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
4136     type = TREE_TYPE (type);
4137   wtype = va_list_type_node;
4138   htype = type;
4139   /* Treat structure va_list types.  */
4140   if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4141     htype = TREE_TYPE (htype);
4142   else if (TREE_CODE (wtype) == ARRAY_TYPE)
4143     {
4144       /* If va_list is an array type, the argument may have decayed
4145          to a pointer type, e.g. by being passed to another function.
4146          In that case, unwrap both types so that we can compare the
4147          underlying records.  */
4148       if (TREE_CODE (htype) == ARRAY_TYPE
4149           || POINTER_TYPE_P (htype))
4150         {
4151           wtype = TREE_TYPE (wtype);
4152           htype = TREE_TYPE (htype);
4153         }
4154     }
4155   if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4156     return va_list_type_node;
4157
4158   return NULL_TREE;
4159 }
4160
4161 /* The "standard" implementation of va_start: just assign `nextarg' to
4162    the variable.  */
4163
4164 void
4165 std_expand_builtin_va_start (tree valist, rtx nextarg)
4166 {
4167   rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4168   convert_move (va_r, nextarg, 0);
4169 }
4170
4171 /* Expand EXP, a call to __builtin_va_start.  */
4172
4173 static rtx
4174 expand_builtin_va_start (tree exp)
4175 {
4176   rtx nextarg;
4177   tree valist;
4178   location_t loc = EXPR_LOCATION (exp);
4179
4180   if (call_expr_nargs (exp) < 2)
4181     {
4182       error_at (loc, "too few arguments to function %<va_start%>");
4183       return const0_rtx;
4184     }
4185
4186   if (fold_builtin_next_arg (exp, true))
4187     return const0_rtx;
4188
4189   nextarg = expand_builtin_next_arg ();
4190   valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4191
4192   if (targetm.expand_builtin_va_start)
4193     targetm.expand_builtin_va_start (valist, nextarg);
4194   else
4195     std_expand_builtin_va_start (valist, nextarg);
4196
4197   return const0_rtx;
4198 }
4199
4200 /* The "standard" implementation of va_arg: read the value from the
4201    current (padded) address and increment by the (padded) size.  */
4202
4203 tree
4204 std_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
4205                           gimple_seq *post_p)
4206 {
4207   tree addr, t, type_size, rounded_size, valist_tmp;
4208   unsigned HOST_WIDE_INT align, boundary;
4209   bool indirect;
4210
4211 #ifdef ARGS_GROW_DOWNWARD
4212   /* All of the alignment and movement below is for args-grow-up machines.
4213      As of 2004, there are only 3 ARGS_GROW_DOWNWARD targets, and they all
4214      implement their own specialized gimplify_va_arg_expr routines.  */
4215   gcc_unreachable ();
4216 #endif
4217
4218   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
4219   if (indirect)
4220     type = build_pointer_type (type);
4221
4222   align = PARM_BOUNDARY / BITS_PER_UNIT;
4223   boundary = targetm.calls.function_arg_boundary (TYPE_MODE (type), type);
4224
4225   /* When we align parameter on stack for caller, if the parameter
4226      alignment is beyond MAX_SUPPORTED_STACK_ALIGNMENT, it will be
4227      aligned at MAX_SUPPORTED_STACK_ALIGNMENT.  We will match callee
4228      here with caller.  */
4229   if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
4230     boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
4231
4232   boundary /= BITS_PER_UNIT;
4233
4234   /* Hoist the valist value into a temporary for the moment.  */
4235   valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
4236
4237   /* va_list pointer is aligned to PARM_BOUNDARY.  If argument actually
4238      requires greater alignment, we must perform dynamic alignment.  */
4239   if (boundary > align
4240       && !integer_zerop (TYPE_SIZE (type)))
4241     {
4242       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4243                   fold_build_pointer_plus_hwi (valist_tmp, boundary - 1));
4244       gimplify_and_add (t, pre_p);
4245
4246       t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
4247                   fold_build2 (BIT_AND_EXPR, TREE_TYPE (valist),
4248                                valist_tmp,
4249                                build_int_cst (TREE_TYPE (valist), -boundary)));
4250       gimplify_and_add (t, pre_p);
4251     }
4252   else
4253     boundary = align;
4254
4255   /* If the actual alignment is less than the alignment of the type,
4256      adjust the type accordingly so that we don't assume strict alignment
4257      when dereferencing the pointer.  */
4258   boundary *= BITS_PER_UNIT;
4259   if (boundary < TYPE_ALIGN (type))
4260     {
4261       type = build_variant_type_copy (type);
4262       TYPE_ALIGN (type) = boundary;
4263     }
4264
4265   /* Compute the rounded size of the type.  */
4266   type_size = size_in_bytes (type);
4267   rounded_size = round_up (type_size, align);
4268
4269   /* Reduce rounded_size so it's sharable with the postqueue.  */
4270   gimplify_expr (&rounded_size, pre_p, post_p, is_gimple_val, fb_rvalue);
4271
4272   /* Get AP.  */
4273   addr = valist_tmp;
4274   if (PAD_VARARGS_DOWN && !integer_zerop (rounded_size))
4275     {
4276       /* Small args are padded downward.  */
4277       t = fold_build2_loc (input_location, GT_EXPR, sizetype,
4278                        rounded_size, size_int (align));
4279       t = fold_build3 (COND_EXPR, sizetype, t, size_zero_node,
4280                        size_binop (MINUS_EXPR, rounded_size, type_size));
4281       addr = fold_build_pointer_plus (addr, t);
4282     }
4283
4284   /* Compute new value for AP.  */
4285   t = fold_build_pointer_plus (valist_tmp, rounded_size);
4286   t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
4287   gimplify_and_add (t, pre_p);
4288
4289   addr = fold_convert (build_pointer_type (type), addr);
4290
4291   if (indirect)
4292     addr = build_va_arg_indirect_ref (addr);
4293
4294   return build_va_arg_indirect_ref (addr);
4295 }
4296
4297 /* Build an indirect-ref expression over the given TREE, which represents a
4298    piece of a va_arg() expansion.  */
4299 tree
4300 build_va_arg_indirect_ref (tree addr)
4301 {
4302   addr = build_simple_mem_ref_loc (EXPR_LOCATION (addr), addr);
4303
4304   if (flag_mudflap) /* Don't instrument va_arg INDIRECT_REF.  */
4305     mf_mark (addr);
4306
4307   return addr;
4308 }
4309
4310 /* Return a dummy expression of type TYPE in order to keep going after an
4311    error.  */
4312
4313 static tree
4314 dummy_object (tree type)
4315 {
4316   tree t = build_int_cst (build_pointer_type (type), 0);
4317   return build2 (MEM_REF, type, t, t);
4318 }
4319
4320 /* Gimplify __builtin_va_arg, aka VA_ARG_EXPR, which is not really a
4321    builtin function, but a very special sort of operator.  */
4322
4323 enum gimplify_status
4324 gimplify_va_arg_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4325 {
4326   tree promoted_type, have_va_type;
4327   tree valist = TREE_OPERAND (*expr_p, 0);
4328   tree type = TREE_TYPE (*expr_p);
4329   tree t;
4330   location_t loc = EXPR_LOCATION (*expr_p);
4331
4332   /* Verify that valist is of the proper type.  */
4333   have_va_type = TREE_TYPE (valist);
4334   if (have_va_type == error_mark_node)
4335     return GS_ERROR;
4336   have_va_type = targetm.canonical_va_list_type (have_va_type);
4337
4338   if (have_va_type == NULL_TREE)
4339     {
4340       error_at (loc, "first argument to %<va_arg%> not of type %<va_list%>");
4341       return GS_ERROR;
4342     }
4343
4344   /* Generate a diagnostic for requesting data of a type that cannot
4345      be passed through `...' due to type promotion at the call site.  */
4346   if ((promoted_type = lang_hooks.types.type_promotes_to (type))
4347            != type)
4348     {
4349       static bool gave_help;
4350       bool warned;
4351
4352       /* Unfortunately, this is merely undefined, rather than a constraint
4353          violation, so we cannot make this an error.  If this call is never
4354          executed, the program is still strictly conforming.  */
4355       warned = warning_at (loc, 0,
4356                            "%qT is promoted to %qT when passed through %<...%>",
4357                            type, promoted_type);
4358       if (!gave_help && warned)
4359         {
4360           gave_help = true;
4361           inform (loc, "(so you should pass %qT not %qT to %<va_arg%>)",
4362                   promoted_type, type);
4363         }
4364
4365       /* We can, however, treat "undefined" any way we please.
4366          Call abort to encourage the user to fix the program.  */
4367       if (warned)
4368         inform (loc, "if this code is reached, the program will abort");
4369       /* Before the abort, allow the evaluation of the va_list
4370          expression to exit or longjmp.  */
4371       gimplify_and_add (valist, pre_p);
4372       t = build_call_expr_loc (loc,
4373                                builtin_decl_implicit (BUILT_IN_TRAP), 0);
4374       gimplify_and_add (t, pre_p);
4375
4376       /* This is dead code, but go ahead and finish so that the
4377          mode of the result comes out right.  */
4378       *expr_p = dummy_object (type);
4379       return GS_ALL_DONE;
4380     }
4381   else
4382     {
4383       /* Make it easier for the backends by protecting the valist argument
4384          from multiple evaluations.  */
4385       if (TREE_CODE (have_va_type) == ARRAY_TYPE)
4386         {
4387           /* For this case, the backends will be expecting a pointer to
4388              TREE_TYPE (abi), but it's possible we've
4389              actually been given an array (an actual TARGET_FN_ABI_VA_LIST).
4390              So fix it.  */
4391           if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4392             {
4393               tree p1 = build_pointer_type (TREE_TYPE (have_va_type));
4394               valist = fold_convert_loc (loc, p1,
4395                                          build_fold_addr_expr_loc (loc, valist));
4396             }
4397
4398           gimplify_expr (&valist, pre_p, post_p, is_gimple_val, fb_rvalue);
4399         }
4400       else
4401         gimplify_expr (&valist, pre_p, post_p, is_gimple_min_lval, fb_lvalue);
4402
4403       if (!targetm.gimplify_va_arg_expr)
4404         /* FIXME: Once most targets are converted we should merely
4405            assert this is non-null.  */
4406         return GS_ALL_DONE;
4407
4408       *expr_p = targetm.gimplify_va_arg_expr (valist, type, pre_p, post_p);
4409       return GS_OK;
4410     }
4411 }
4412
4413 /* Expand EXP, a call to __builtin_va_end.  */
4414
4415 static rtx
4416 expand_builtin_va_end (tree exp)
4417 {
4418   tree valist = CALL_EXPR_ARG (exp, 0);
4419
4420   /* Evaluate for side effects, if needed.  I hate macros that don't
4421      do that.  */
4422   if (TREE_SIDE_EFFECTS (valist))
4423     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4424
4425   return const0_rtx;
4426 }
4427
4428 /* Expand EXP, a call to __builtin_va_copy.  We do this as a
4429    builtin rather than just as an assignment in stdarg.h because of the
4430    nastiness of array-type va_list types.  */
4431
4432 static rtx
4433 expand_builtin_va_copy (tree exp)
4434 {
4435   tree dst, src, t;
4436   location_t loc = EXPR_LOCATION (exp);
4437
4438   dst = CALL_EXPR_ARG (exp, 0);
4439   src = CALL_EXPR_ARG (exp, 1);
4440
4441   dst = stabilize_va_list_loc (loc, dst, 1);
4442   src = stabilize_va_list_loc (loc, src, 0);
4443
4444   gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4445
4446   if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4447     {
4448       t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4449       TREE_SIDE_EFFECTS (t) = 1;
4450       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4451     }
4452   else
4453     {
4454       rtx dstb, srcb, size;
4455
4456       /* Evaluate to pointers.  */
4457       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4458       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4459       size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4460                   NULL_RTX, VOIDmode, EXPAND_NORMAL);
4461
4462       dstb = convert_memory_address (Pmode, dstb);
4463       srcb = convert_memory_address (Pmode, srcb);
4464
4465       /* "Dereference" to BLKmode memories.  */
4466       dstb = gen_rtx_MEM (BLKmode, dstb);
4467       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4468       set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4469       srcb = gen_rtx_MEM (BLKmode, srcb);
4470       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4471       set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4472
4473       /* Copy.  */
4474       emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4475     }
4476
4477   return const0_rtx;
4478 }
4479
4480 /* Expand a call to one of the builtin functions __builtin_frame_address or
4481    __builtin_return_address.  */
4482
4483 static rtx
4484 expand_builtin_frame_address (tree fndecl, tree exp)
4485 {
4486   /* The argument must be a nonnegative integer constant.
4487      It counts the number of frames to scan up the stack.
4488      The value is the return address saved in that frame.  */
4489   if (call_expr_nargs (exp) == 0)
4490     /* Warning about missing arg was already issued.  */
4491     return const0_rtx;
4492   else if (! host_integerp (CALL_EXPR_ARG (exp, 0), 1))
4493     {
4494       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4495         error ("invalid argument to %<__builtin_frame_address%>");
4496       else
4497         error ("invalid argument to %<__builtin_return_address%>");
4498       return const0_rtx;
4499     }
4500   else
4501     {
4502       rtx tem
4503         = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl),
4504                                       tree_low_cst (CALL_EXPR_ARG (exp, 0), 1));
4505
4506       /* Some ports cannot access arbitrary stack frames.  */
4507       if (tem == NULL)
4508         {
4509           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4510             warning (0, "unsupported argument to %<__builtin_frame_address%>");
4511           else
4512             warning (0, "unsupported argument to %<__builtin_return_address%>");
4513           return const0_rtx;
4514         }
4515
4516       /* For __builtin_frame_address, return what we've got.  */
4517       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4518         return tem;
4519
4520       if (!REG_P (tem)
4521           && ! CONSTANT_P (tem))
4522         tem = copy_addr_to_reg (tem);
4523       return tem;
4524     }
4525 }
4526
4527 /* Expand EXP, a call to the alloca builtin.  Return NULL_RTX if we
4528    failed and the caller should emit a normal call.  CANNOT_ACCUMULATE
4529    is the same as for allocate_dynamic_stack_space.  */
4530
4531 static rtx
4532 expand_builtin_alloca (tree exp, bool cannot_accumulate)
4533 {
4534   rtx op0;
4535   rtx result;
4536   bool valid_arglist;
4537   unsigned int align;
4538   bool alloca_with_align = (DECL_FUNCTION_CODE (get_callee_fndecl (exp))
4539                             == BUILT_IN_ALLOCA_WITH_ALIGN);
4540
4541   /* Emit normal call if we use mudflap.  */
4542   if (flag_mudflap)
4543     return NULL_RTX;
4544
4545   valid_arglist
4546     = (alloca_with_align
4547        ? validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE)
4548        : validate_arglist (exp, INTEGER_TYPE, VOID_TYPE));
4549
4550   if (!valid_arglist)
4551     return NULL_RTX;
4552
4553   /* Compute the argument.  */
4554   op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4555
4556   /* Compute the alignment.  */
4557   align = (alloca_with_align
4558            ? TREE_INT_CST_LOW (CALL_EXPR_ARG (exp, 1))
4559            : BIGGEST_ALIGNMENT);
4560
4561   /* Allocate the desired space.  */
4562   result = allocate_dynamic_stack_space (op0, 0, align, cannot_accumulate);
4563   result = convert_memory_address (ptr_mode, result);
4564
4565   return result;
4566 }
4567
4568 /* Expand a call to bswap builtin in EXP.
4569    Return NULL_RTX if a normal call should be emitted rather than expanding the
4570    function in-line.  If convenient, the result should be placed in TARGET.
4571    SUBTARGET may be used as the target for computing one of EXP's operands.  */
4572
4573 static rtx
4574 expand_builtin_bswap (enum machine_mode target_mode, tree exp, rtx target,
4575                       rtx subtarget)
4576 {
4577   tree arg;
4578   rtx op0;
4579
4580   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4581     return NULL_RTX;
4582
4583   arg = CALL_EXPR_ARG (exp, 0);
4584   op0 = expand_expr (arg,
4585                      subtarget && GET_MODE (subtarget) == target_mode
4586                      ? subtarget : NULL_RTX,
4587                      target_mode, EXPAND_NORMAL);
4588   if (GET_MODE (op0) != target_mode)
4589     op0 = convert_to_mode (target_mode, op0, 1);
4590
4591   target = expand_unop (target_mode, bswap_optab, op0, target, 1);
4592
4593   gcc_assert (target);
4594
4595   return convert_to_mode (target_mode, target, 1);
4596 }
4597
4598 /* Expand a call to a unary builtin in EXP.
4599    Return NULL_RTX if a normal call should be emitted rather than expanding the
4600    function in-line.  If convenient, the result should be placed in TARGET.
4601    SUBTARGET may be used as the target for computing one of EXP's operands.  */
4602
4603 static rtx
4604 expand_builtin_unop (enum machine_mode target_mode, tree exp, rtx target,
4605                      rtx subtarget, optab op_optab)
4606 {
4607   rtx op0;
4608
4609   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4610     return NULL_RTX;
4611
4612   /* Compute the argument.  */
4613   op0 = expand_expr (CALL_EXPR_ARG (exp, 0),
4614                      (subtarget
4615                       && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0)))
4616                           == GET_MODE (subtarget))) ? subtarget : NULL_RTX,
4617                      VOIDmode, EXPAND_NORMAL);
4618   /* Compute op, into TARGET if possible.
4619      Set TARGET to wherever the result comes back.  */
4620   target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
4621                         op_optab, op0, target, op_optab != clrsb_optab);
4622   gcc_assert (target);
4623
4624   return convert_to_mode (target_mode, target, 0);
4625 }
4626
4627 /* Expand a call to __builtin_expect.  We just return our argument
4628    as the builtin_expect semantic should've been already executed by
4629    tree branch prediction pass. */
4630
4631 static rtx
4632 expand_builtin_expect (tree exp, rtx target)
4633 {
4634   tree arg;
4635
4636   if (call_expr_nargs (exp) < 2)
4637     return const0_rtx;
4638   arg = CALL_EXPR_ARG (exp, 0);
4639
4640   target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4641   /* When guessing was done, the hints should be already stripped away.  */
4642   gcc_assert (!flag_guess_branch_prob
4643               || optimize == 0 || seen_error ());
4644   return target;
4645 }
4646
4647 /* Expand a call to __builtin_assume_aligned.  We just return our first
4648    argument as the builtin_assume_aligned semantic should've been already
4649    executed by CCP.  */
4650
4651 static rtx
4652 expand_builtin_assume_aligned (tree exp, rtx target)
4653 {
4654   if (call_expr_nargs (exp) < 2)
4655     return const0_rtx;
4656   target = expand_expr (CALL_EXPR_ARG (exp, 0), target, VOIDmode,
4657                         EXPAND_NORMAL);
4658   gcc_assert (!TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 1))
4659               && (call_expr_nargs (exp) < 3
4660                   || !TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 2))));
4661   return target;
4662 }
4663
4664 void
4665 expand_builtin_trap (void)
4666 {
4667 #ifdef HAVE_trap
4668   if (HAVE_trap)
4669     emit_insn (gen_trap ());
4670   else
4671 #endif
4672     emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4673   emit_barrier ();
4674 }
4675
4676 /* Expand a call to __builtin_unreachable.  We do nothing except emit
4677    a barrier saying that control flow will not pass here.
4678
4679    It is the responsibility of the program being compiled to ensure
4680    that control flow does never reach __builtin_unreachable.  */
4681 static void
4682 expand_builtin_unreachable (void)
4683 {
4684   emit_barrier ();
4685 }
4686
4687 /* Expand EXP, a call to fabs, fabsf or fabsl.
4688    Return NULL_RTX if a normal call should be emitted rather than expanding
4689    the function inline.  If convenient, the result should be placed
4690    in TARGET.  SUBTARGET may be used as the target for computing
4691    the operand.  */
4692
4693 static rtx
4694 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
4695 {
4696   enum machine_mode mode;
4697   tree arg;
4698   rtx op0;
4699
4700   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4701     return NULL_RTX;
4702
4703   arg = CALL_EXPR_ARG (exp, 0);
4704   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
4705   mode = TYPE_MODE (TREE_TYPE (arg));
4706   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4707   return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4708 }
4709
4710 /* Expand EXP, a call to copysign, copysignf, or copysignl.
4711    Return NULL is a normal call should be emitted rather than expanding the
4712    function inline.  If convenient, the result should be placed in TARGET.
4713    SUBTARGET may be used as the target for computing the operand.  */
4714
4715 static rtx
4716 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
4717 {
4718   rtx op0, op1;
4719   tree arg;
4720
4721   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
4722     return NULL_RTX;
4723
4724   arg = CALL_EXPR_ARG (exp, 0);
4725   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4726
4727   arg = CALL_EXPR_ARG (exp, 1);
4728   op1 = expand_normal (arg);
4729
4730   return expand_copysign (op0, op1, target);
4731 }
4732
4733 /* Create a new constant string literal and return a char* pointer to it.
4734    The STRING_CST value is the LEN characters at STR.  */
4735 tree
4736 build_string_literal (int len, const char *str)
4737 {
4738   tree t, elem, index, type;
4739
4740   t = build_string (len, str);
4741   elem = build_type_variant (char_type_node, 1, 0);
4742   index = build_index_type (size_int (len - 1));
4743   type = build_array_type (elem, index);
4744   TREE_TYPE (t) = type;
4745   TREE_CONSTANT (t) = 1;
4746   TREE_READONLY (t) = 1;
4747   TREE_STATIC (t) = 1;
4748
4749   type = build_pointer_type (elem);
4750   t = build1 (ADDR_EXPR, type,
4751               build4 (ARRAY_REF, elem,
4752                       t, integer_zero_node, NULL_TREE, NULL_TREE));
4753   return t;
4754 }
4755
4756 /* Expand a call to __builtin___clear_cache.  */
4757
4758 static rtx
4759 expand_builtin___clear_cache (tree exp ATTRIBUTE_UNUSED)
4760 {
4761 #ifndef HAVE_clear_cache
4762 #ifdef CLEAR_INSN_CACHE
4763   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4764      does something.  Just do the default expansion to a call to
4765      __clear_cache().  */
4766   return NULL_RTX;
4767 #else
4768   /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4769      does nothing.  There is no need to call it.  Do nothing.  */
4770   return const0_rtx;
4771 #endif /* CLEAR_INSN_CACHE */
4772 #else
4773   /* We have a "clear_cache" insn, and it will handle everything.  */
4774   tree begin, end;
4775   rtx begin_rtx, end_rtx;
4776
4777   /* We must not expand to a library call.  If we did, any
4778      fallback library function in libgcc that might contain a call to
4779      __builtin___clear_cache() would recurse infinitely.  */
4780   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4781     {
4782       error ("both arguments to %<__builtin___clear_cache%> must be pointers");
4783       return const0_rtx;
4784     }
4785
4786   if (HAVE_clear_cache)
4787     {
4788       struct expand_operand ops[2];
4789
4790       begin = CALL_EXPR_ARG (exp, 0);
4791       begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
4792
4793       end = CALL_EXPR_ARG (exp, 1);
4794       end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
4795
4796       create_address_operand (&ops[0], begin_rtx);
4797       create_address_operand (&ops[1], end_rtx);
4798       if (maybe_expand_insn (CODE_FOR_clear_cache, 2, ops))
4799         return const0_rtx;
4800     }
4801   return const0_rtx;
4802 #endif /* HAVE_clear_cache */
4803 }
4804
4805 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT.  */
4806
4807 static rtx
4808 round_trampoline_addr (rtx tramp)
4809 {
4810   rtx temp, addend, mask;
4811
4812   /* If we don't need too much alignment, we'll have been guaranteed
4813      proper alignment by get_trampoline_type.  */
4814   if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
4815     return tramp;
4816
4817   /* Round address up to desired boundary.  */
4818   temp = gen_reg_rtx (Pmode);
4819   addend = GEN_INT (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1);
4820   mask = GEN_INT (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
4821
4822   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
4823                                temp, 0, OPTAB_LIB_WIDEN);
4824   tramp = expand_simple_binop (Pmode, AND, temp, mask,
4825                                temp, 0, OPTAB_LIB_WIDEN);
4826
4827   return tramp;
4828 }
4829
4830 static rtx
4831 expand_builtin_init_trampoline (tree exp, bool onstack)
4832 {
4833   tree t_tramp, t_func, t_chain;
4834   rtx m_tramp, r_tramp, r_chain, tmp;
4835
4836   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
4837                          POINTER_TYPE, VOID_TYPE))
4838     return NULL_RTX;
4839
4840   t_tramp = CALL_EXPR_ARG (exp, 0);
4841   t_func = CALL_EXPR_ARG (exp, 1);
4842   t_chain = CALL_EXPR_ARG (exp, 2);
4843
4844   r_tramp = expand_normal (t_tramp);
4845   m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
4846   MEM_NOTRAP_P (m_tramp) = 1;
4847
4848   /* If ONSTACK, the TRAMP argument should be the address of a field
4849      within the local function's FRAME decl.  Either way, let's see if
4850      we can fill in the MEM_ATTRs for this memory.  */
4851   if (TREE_CODE (t_tramp) == ADDR_EXPR)
4852     set_mem_attributes_minus_bitpos (m_tramp, TREE_OPERAND (t_tramp, 0),
4853                                      true, 0);
4854
4855   /* Creator of a heap trampoline is responsible for making sure the
4856      address is aligned to at least STACK_BOUNDARY.  Normally malloc
4857      will ensure this anyhow.  */
4858   tmp = round_trampoline_addr (r_tramp);
4859   if (tmp != r_tramp)
4860     {
4861       m_tramp = change_address (m_tramp, BLKmode, tmp);
4862       set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
4863       set_mem_size (m_tramp, TRAMPOLINE_SIZE);
4864     }
4865
4866   /* The FUNC argument should be the address of the nested function.
4867      Extract the actual function decl to pass to the hook.  */
4868   gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
4869   t_func = TREE_OPERAND (t_func, 0);
4870   gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
4871
4872   r_chain = expand_normal (t_chain);
4873
4874   /* Generate insns to initialize the trampoline.  */
4875   targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
4876
4877   if (onstack)
4878     {
4879       trampolines_created = 1;
4880
4881       warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
4882                   "trampoline generated for nested function %qD", t_func);
4883     }
4884
4885   return const0_rtx;
4886 }
4887
4888 static rtx
4889 expand_builtin_adjust_trampoline (tree exp)
4890 {
4891   rtx tramp;
4892
4893   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
4894     return NULL_RTX;
4895
4896   tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
4897   tramp = round_trampoline_addr (tramp);
4898   if (targetm.calls.trampoline_adjust_address)
4899     tramp = targetm.calls.trampoline_adjust_address (tramp);
4900
4901   return tramp;
4902 }
4903
4904 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
4905    function.  The function first checks whether the back end provides
4906    an insn to implement signbit for the respective mode.  If not, it
4907    checks whether the floating point format of the value is such that
4908    the sign bit can be extracted.  If that is not the case, the
4909    function returns NULL_RTX to indicate that a normal call should be
4910    emitted rather than expanding the function in-line.  EXP is the
4911    expression that is a call to the builtin function; if convenient,
4912    the result should be placed in TARGET.  */
4913 static rtx
4914 expand_builtin_signbit (tree exp, rtx target)
4915 {
4916   const struct real_format *fmt;
4917   enum machine_mode fmode, imode, rmode;
4918   tree arg;
4919   int word, bitpos;
4920   enum insn_code icode;
4921   rtx temp;
4922   location_t loc = EXPR_LOCATION (exp);
4923
4924   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4925     return NULL_RTX;
4926
4927   arg = CALL_EXPR_ARG (exp, 0);
4928   fmode = TYPE_MODE (TREE_TYPE (arg));
4929   rmode = TYPE_MODE (TREE_TYPE (exp));
4930   fmt = REAL_MODE_FORMAT (fmode);
4931
4932   arg = builtin_save_expr (arg);
4933
4934   /* Expand the argument yielding a RTX expression. */
4935   temp = expand_normal (arg);
4936
4937   /* Check if the back end provides an insn that handles signbit for the
4938      argument's mode. */
4939   icode = optab_handler (signbit_optab, fmode);
4940   if (icode != CODE_FOR_nothing)
4941     {
4942       rtx last = get_last_insn ();
4943       target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
4944       if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
4945         return target;
4946       delete_insns_since (last);
4947     }
4948
4949   /* For floating point formats without a sign bit, implement signbit
4950      as "ARG < 0.0".  */
4951   bitpos = fmt->signbit_ro;
4952   if (bitpos < 0)
4953   {
4954     /* But we can't do this if the format supports signed zero.  */
4955     if (fmt->has_signed_zero && HONOR_SIGNED_ZEROS (fmode))
4956       return NULL_RTX;
4957
4958     arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
4959                        build_real (TREE_TYPE (arg), dconst0));
4960     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4961   }
4962
4963   if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
4964     {
4965       imode = int_mode_for_mode (fmode);
4966       if (imode == BLKmode)
4967         return NULL_RTX;
4968       temp = gen_lowpart (imode, temp);
4969     }
4970   else
4971     {
4972       imode = word_mode;
4973       /* Handle targets with different FP word orders.  */
4974       if (FLOAT_WORDS_BIG_ENDIAN)
4975         word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
4976       else
4977         word = bitpos / BITS_PER_WORD;
4978       temp = operand_subword_force (temp, word, fmode);
4979       bitpos = bitpos % BITS_PER_WORD;
4980     }
4981
4982   /* Force the intermediate word_mode (or narrower) result into a
4983      register.  This avoids attempting to create paradoxical SUBREGs
4984      of floating point modes below.  */
4985   temp = force_reg (imode, temp);
4986
4987   /* If the bitpos is within the "result mode" lowpart, the operation
4988      can be implement with a single bitwise AND.  Otherwise, we need
4989      a right shift and an AND.  */
4990
4991   if (bitpos < GET_MODE_BITSIZE (rmode))
4992     {
4993       double_int mask = double_int_setbit (double_int_zero, bitpos);
4994
4995       if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
4996         temp = gen_lowpart (rmode, temp);
4997       temp = expand_binop (rmode, and_optab, temp,
4998                            immed_double_int_const (mask, rmode),
4999                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5000     }
5001   else
5002     {
5003       /* Perform a logical right shift to place the signbit in the least
5004          significant bit, then truncate the result to the desired mode
5005          and mask just this bit.  */
5006       temp = expand_shift (RSHIFT_EXPR, imode, temp, bitpos, NULL_RTX, 1);
5007       temp = gen_lowpart (rmode, temp);
5008       temp = expand_binop (rmode, and_optab, temp, const1_rtx,
5009                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
5010     }
5011
5012   return temp;
5013 }
5014
5015 /* Expand fork or exec calls.  TARGET is the desired target of the
5016    call.  EXP is the call. FN is the
5017    identificator of the actual function.  IGNORE is nonzero if the
5018    value is to be ignored.  */
5019
5020 static rtx
5021 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
5022 {
5023   tree id, decl;
5024   tree call;
5025
5026   /* If we are not profiling, just call the function.  */
5027   if (!profile_arc_flag)
5028     return NULL_RTX;
5029
5030   /* Otherwise call the wrapper.  This should be equivalent for the rest of
5031      compiler, so the code does not diverge, and the wrapper may run the
5032      code necessary for keeping the profiling sane.  */
5033
5034   switch (DECL_FUNCTION_CODE (fn))
5035     {
5036     case BUILT_IN_FORK:
5037       id = get_identifier ("__gcov_fork");
5038       break;
5039
5040     case BUILT_IN_EXECL:
5041       id = get_identifier ("__gcov_execl");
5042       break;
5043
5044     case BUILT_IN_EXECV:
5045       id = get_identifier ("__gcov_execv");
5046       break;
5047
5048     case BUILT_IN_EXECLP:
5049       id = get_identifier ("__gcov_execlp");
5050       break;
5051
5052     case BUILT_IN_EXECLE:
5053       id = get_identifier ("__gcov_execle");
5054       break;
5055
5056     case BUILT_IN_EXECVP:
5057       id = get_identifier ("__gcov_execvp");
5058       break;
5059
5060     case BUILT_IN_EXECVE:
5061       id = get_identifier ("__gcov_execve");
5062       break;
5063
5064     default:
5065       gcc_unreachable ();
5066     }
5067
5068   decl = build_decl (DECL_SOURCE_LOCATION (fn),
5069                      FUNCTION_DECL, id, TREE_TYPE (fn));
5070   DECL_EXTERNAL (decl) = 1;
5071   TREE_PUBLIC (decl) = 1;
5072   DECL_ARTIFICIAL (decl) = 1;
5073   TREE_NOTHROW (decl) = 1;
5074   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5075   DECL_VISIBILITY_SPECIFIED (decl) = 1;
5076   call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
5077   return expand_call (call, target, ignore);
5078  }
5079
5080
5081 \f
5082 /* Reconstitute a mode for a __sync intrinsic operation.  Since the type of
5083    the pointer in these functions is void*, the tree optimizers may remove
5084    casts.  The mode computed in expand_builtin isn't reliable either, due
5085    to __sync_bool_compare_and_swap.
5086
5087    FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
5088    group of builtins.  This gives us log2 of the mode size.  */
5089
5090 static inline enum machine_mode
5091 get_builtin_sync_mode (int fcode_diff)
5092 {
5093   /* The size is not negotiable, so ask not to get BLKmode in return
5094      if the target indicates that a smaller size would be better.  */
5095   return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
5096 }
5097
5098 /* Expand the memory expression LOC and return the appropriate memory operand
5099    for the builtin_sync operations.  */
5100
5101 static rtx
5102 get_builtin_sync_mem (tree loc, enum machine_mode mode)
5103 {
5104   rtx addr, mem;
5105
5106   addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
5107   addr = convert_memory_address (Pmode, addr);
5108
5109   /* Note that we explicitly do not want any alias information for this
5110      memory, so that we kill all other live memories.  Otherwise we don't
5111      satisfy the full barrier semantics of the intrinsic.  */
5112   mem = validize_mem (gen_rtx_MEM (mode, addr));
5113
5114   /* The alignment needs to be at least according to that of the mode.  */
5115   set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
5116                            get_pointer_alignment (loc)));
5117   set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
5118   MEM_VOLATILE_P (mem) = 1;
5119
5120   return mem;
5121 }
5122
5123 /* Make sure an argument is in the right mode.
5124    EXP is the tree argument.
5125    MODE is the mode it should be in.  */
5126
5127 static rtx
5128 expand_expr_force_mode (tree exp, enum machine_mode mode)
5129 {
5130   rtx val;
5131   enum machine_mode old_mode;
5132
5133   val = expand_expr (exp, NULL_RTX, mode, EXPAND_NORMAL);
5134   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
5135      of CONST_INTs, where we know the old_mode only from the call argument.  */
5136
5137   old_mode = GET_MODE (val);
5138   if (old_mode == VOIDmode)
5139     old_mode = TYPE_MODE (TREE_TYPE (exp));
5140   val = convert_modes (mode, old_mode, val, 1);
5141   return val;
5142 }
5143
5144
5145 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
5146    EXP is the CALL_EXPR.  CODE is the rtx code
5147    that corresponds to the arithmetic or logical operation from the name;
5148    an exception here is that NOT actually means NAND.  TARGET is an optional
5149    place for us to store the results; AFTER is true if this is the
5150    fetch_and_xxx form.  */
5151
5152 static rtx
5153 expand_builtin_sync_operation (enum machine_mode mode, tree exp,
5154                                enum rtx_code code, bool after,
5155                                rtx target)
5156 {
5157   rtx val, mem;
5158   location_t loc = EXPR_LOCATION (exp);
5159
5160   if (code == NOT && warn_sync_nand)
5161     {
5162       tree fndecl = get_callee_fndecl (exp);
5163       enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5164
5165       static bool warned_f_a_n, warned_n_a_f;
5166
5167       switch (fcode)
5168         {
5169         case BUILT_IN_SYNC_FETCH_AND_NAND_1:
5170         case BUILT_IN_SYNC_FETCH_AND_NAND_2:
5171         case BUILT_IN_SYNC_FETCH_AND_NAND_4:
5172         case BUILT_IN_SYNC_FETCH_AND_NAND_8:
5173         case BUILT_IN_SYNC_FETCH_AND_NAND_16:
5174           if (warned_f_a_n)
5175             break;
5176
5177           fndecl = builtin_decl_implicit (BUILT_IN_SYNC_FETCH_AND_NAND_N);
5178           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5179           warned_f_a_n = true;
5180           break;
5181
5182         case BUILT_IN_SYNC_NAND_AND_FETCH_1:
5183         case BUILT_IN_SYNC_NAND_AND_FETCH_2:
5184         case BUILT_IN_SYNC_NAND_AND_FETCH_4:
5185         case BUILT_IN_SYNC_NAND_AND_FETCH_8:
5186         case BUILT_IN_SYNC_NAND_AND_FETCH_16:
5187           if (warned_n_a_f)
5188             break;
5189
5190          fndecl = builtin_decl_implicit (BUILT_IN_SYNC_NAND_AND_FETCH_N);
5191           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
5192           warned_n_a_f = true;
5193           break;
5194
5195         default:
5196           gcc_unreachable ();
5197         }
5198     }
5199
5200   /* Expand the operands.  */
5201   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5202   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5203
5204   return expand_atomic_fetch_op (target, mem, val, code, MEMMODEL_SEQ_CST,
5205                                  after);
5206 }
5207
5208 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
5209    intrinsics. EXP is the CALL_EXPR.  IS_BOOL is
5210    true if this is the boolean form.  TARGET is a place for us to store the
5211    results; this is NOT optional if IS_BOOL is true.  */
5212
5213 static rtx
5214 expand_builtin_compare_and_swap (enum machine_mode mode, tree exp,
5215                                  bool is_bool, rtx target)
5216 {
5217   rtx old_val, new_val, mem;
5218   rtx *pbool, *poval;
5219
5220   /* Expand the operands.  */
5221   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5222   old_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5223   new_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode);
5224
5225   pbool = poval = NULL;
5226   if (target != const0_rtx)
5227     {
5228       if (is_bool)
5229         pbool = &target;
5230       else
5231         poval = &target;
5232     }
5233   if (!expand_atomic_compare_and_swap (pbool, poval, mem, old_val, new_val,
5234                                        false, MEMMODEL_SEQ_CST,
5235                                        MEMMODEL_SEQ_CST))
5236     return NULL_RTX;
5237
5238   return target;
5239 }
5240
5241 /* Expand the __sync_lock_test_and_set intrinsic.  Note that the most
5242    general form is actually an atomic exchange, and some targets only
5243    support a reduced form with the second argument being a constant 1.
5244    EXP is the CALL_EXPR; TARGET is an optional place for us to store
5245    the results.  */
5246
5247 static rtx
5248 expand_builtin_sync_lock_test_and_set (enum machine_mode mode, tree exp,
5249                                        rtx target)
5250 {
5251   rtx val, mem;
5252
5253   /* Expand the operands.  */
5254   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5255   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5256
5257   return expand_sync_lock_test_and_set (target, mem, val);
5258 }
5259
5260 /* Expand the __sync_lock_release intrinsic.  EXP is the CALL_EXPR.  */
5261
5262 static void
5263 expand_builtin_sync_lock_release (enum machine_mode mode, tree exp)
5264 {
5265   rtx mem;
5266
5267   /* Expand the operands.  */
5268   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5269
5270   expand_atomic_store (mem, const0_rtx, MEMMODEL_RELEASE, true);
5271 }
5272
5273 /* Given an integer representing an ``enum memmodel'', verify its
5274    correctness and return the memory model enum.  */
5275
5276 static enum memmodel
5277 get_memmodel (tree exp)
5278 {
5279   rtx op;
5280   unsigned HOST_WIDE_INT val;
5281
5282   /* If the parameter is not a constant, it's a run time value so we'll just
5283      convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking.  */
5284   if (TREE_CODE (exp) != INTEGER_CST)
5285     return MEMMODEL_SEQ_CST;
5286
5287   op = expand_normal (exp);
5288
5289   val = INTVAL (op);
5290   if (targetm.memmodel_check)
5291     val = targetm.memmodel_check (val);
5292   else if (val & ~MEMMODEL_MASK)
5293     {
5294       warning (OPT_Winvalid_memory_model,
5295                "Unknown architecture specifier in memory model to builtin.");
5296       return MEMMODEL_SEQ_CST;
5297     }
5298
5299   if ((INTVAL(op) & MEMMODEL_MASK) >= MEMMODEL_LAST)
5300     {
5301       warning (OPT_Winvalid_memory_model,
5302                "invalid memory model argument to builtin");
5303       return MEMMODEL_SEQ_CST;
5304     }
5305
5306   return (enum memmodel) val;
5307 }
5308
5309 /* Expand the __atomic_exchange intrinsic:
5310         TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel)
5311    EXP is the CALL_EXPR.
5312    TARGET is an optional place for us to store the results.  */
5313
5314 static rtx
5315 expand_builtin_atomic_exchange (enum machine_mode mode, tree exp, rtx target)
5316 {
5317   rtx val, mem;
5318   enum memmodel model;
5319
5320   model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5321   if ((model & MEMMODEL_MASK) == MEMMODEL_CONSUME)
5322     {
5323       error ("invalid memory model for %<__atomic_exchange%>");
5324       return NULL_RTX;
5325     }
5326
5327   if (!flag_inline_atomics)
5328     return NULL_RTX;
5329
5330   /* Expand the operands.  */
5331   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5332   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5333
5334   return expand_atomic_exchange (target, mem, val, model);
5335 }
5336
5337 /* Expand the __atomic_compare_exchange intrinsic:
5338         bool __atomic_compare_exchange (TYPE *object, TYPE *expect,
5339                                         TYPE desired, BOOL weak,
5340                                         enum memmodel success,
5341                                         enum memmodel failure)
5342    EXP is the CALL_EXPR.
5343    TARGET is an optional place for us to store the results.  */
5344
5345 static rtx
5346 expand_builtin_atomic_compare_exchange (enum machine_mode mode, tree exp,
5347                                         rtx target)
5348 {
5349   rtx expect, desired, mem, oldval;
5350   enum memmodel success, failure;
5351   tree weak;
5352   bool is_weak;
5353
5354   success = get_memmodel (CALL_EXPR_ARG (exp, 4));
5355   failure = get_memmodel (CALL_EXPR_ARG (exp, 5));
5356
5357   if ((failure & MEMMODEL_MASK) == MEMMODEL_RELEASE
5358       || (failure & MEMMODEL_MASK) == MEMMODEL_ACQ_REL)
5359     {
5360       error ("invalid failure memory model for %<__atomic_compare_exchange%>");
5361       return NULL_RTX;
5362     }
5363
5364   if (failure > success)
5365     {
5366       error ("failure memory model cannot be stronger than success "
5367              "memory model for %<__atomic_compare_exchange%>");
5368       return NULL_RTX;
5369     }
5370
5371   if (!flag_inline_atomics)
5372     return NULL_RTX;
5373
5374   /* Expand the operands.  */
5375   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5376
5377   expect = expand_normal (CALL_EXPR_ARG (exp, 1));
5378   expect = convert_memory_address (Pmode, expect);
5379   desired = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode);
5380
5381   weak = CALL_EXPR_ARG (exp, 3);
5382   is_weak = false;
5383   if (host_integerp (weak, 0) && tree_low_cst (weak, 0) != 0)
5384     is_weak = true;
5385
5386   oldval = copy_to_reg (gen_rtx_MEM (mode, expect));
5387
5388   if (!expand_atomic_compare_and_swap ((target == const0_rtx ? NULL : &target),
5389                                        &oldval, mem, oldval, desired,
5390                                        is_weak, success, failure))
5391     return NULL_RTX;
5392
5393   emit_move_insn (gen_rtx_MEM (mode, expect), oldval);
5394   return target;
5395 }
5396
5397 /* Expand the __atomic_load intrinsic:
5398         TYPE __atomic_load (TYPE *object, enum memmodel)
5399    EXP is the CALL_EXPR.
5400    TARGET is an optional place for us to store the results.  */
5401
5402 static rtx
5403 expand_builtin_atomic_load (enum machine_mode mode, tree exp, rtx target)
5404 {
5405   rtx mem;
5406   enum memmodel model;
5407
5408   model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5409   if ((model & MEMMODEL_MASK) == MEMMODEL_RELEASE
5410       || (model & MEMMODEL_MASK) == MEMMODEL_ACQ_REL)
5411     {
5412       error ("invalid memory model for %<__atomic_load%>");
5413       return NULL_RTX;
5414     }
5415
5416   if (!flag_inline_atomics)
5417     return NULL_RTX;
5418
5419   /* Expand the operand.  */
5420   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5421
5422   return expand_atomic_load (target, mem, model);
5423 }
5424
5425
5426 /* Expand the __atomic_store intrinsic:
5427         void __atomic_store (TYPE *object, TYPE desired, enum memmodel)
5428    EXP is the CALL_EXPR.
5429    TARGET is an optional place for us to store the results.  */
5430
5431 static rtx
5432 expand_builtin_atomic_store (enum machine_mode mode, tree exp)
5433 {
5434   rtx mem, val;
5435   enum memmodel model;
5436
5437   model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5438   if ((model & MEMMODEL_MASK) != MEMMODEL_RELAXED
5439       && (model & MEMMODEL_MASK) != MEMMODEL_SEQ_CST
5440       && (model & MEMMODEL_MASK) != MEMMODEL_RELEASE)
5441     {
5442       error ("invalid memory model for %<__atomic_store%>");
5443       return NULL_RTX;
5444     }
5445
5446   if (!flag_inline_atomics)
5447     return NULL_RTX;
5448
5449   /* Expand the operands.  */
5450   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5451   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5452
5453   return expand_atomic_store (mem, val, model, false);
5454 }
5455
5456 /* Expand the __atomic_fetch_XXX intrinsic:
5457         TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel)
5458    EXP is the CALL_EXPR.
5459    TARGET is an optional place for us to store the results.
5460    CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR.
5461    FETCH_AFTER is true if returning the result of the operation.
5462    FETCH_AFTER is false if returning the value before the operation.
5463    IGNORE is true if the result is not used.
5464    EXT_CALL is the correct builtin for an external call if this cannot be
5465    resolved to an instruction sequence.  */
5466
5467 static rtx
5468 expand_builtin_atomic_fetch_op (enum machine_mode mode, tree exp, rtx target,
5469                                 enum rtx_code code, bool fetch_after,
5470                                 bool ignore, enum built_in_function ext_call)
5471 {
5472   rtx val, mem, ret;
5473   enum memmodel model;
5474   tree fndecl;
5475   tree addr;
5476
5477   model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5478
5479   /* Expand the operands.  */
5480   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5481   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5482
5483   /* Only try generating instructions if inlining is turned on.  */
5484   if (flag_inline_atomics)
5485     {
5486       ret = expand_atomic_fetch_op (target, mem, val, code, model, fetch_after);
5487       if (ret)
5488         return ret;
5489     }
5490
5491   /* Return if a different routine isn't needed for the library call.  */
5492   if (ext_call == BUILT_IN_NONE)
5493     return NULL_RTX;
5494
5495   /* Change the call to the specified function.  */
5496   fndecl = get_callee_fndecl (exp);
5497   addr = CALL_EXPR_FN (exp);
5498   STRIP_NOPS (addr);
5499
5500   gcc_assert (TREE_OPERAND (addr, 0) == fndecl);
5501   TREE_OPERAND (addr, 0) = builtin_decl_explicit(ext_call);
5502
5503   /* Expand the call here so we can emit trailing code.  */
5504   ret = expand_call (exp, target, ignore);
5505
5506   /* Replace the original function just in case it matters.  */
5507   TREE_OPERAND (addr, 0) = fndecl;
5508
5509   /* Then issue the arithmetic correction to return the right result.  */
5510   if (!ignore)
5511     {
5512       if (code == NOT)
5513         {
5514           ret = expand_simple_binop (mode, AND, ret, val, NULL_RTX, true,
5515                                      OPTAB_LIB_WIDEN);
5516           ret = expand_simple_unop (mode, NOT, ret, target, true);
5517         }
5518       else
5519         ret = expand_simple_binop (mode, code, ret, val, target, true,
5520                                    OPTAB_LIB_WIDEN);
5521     }
5522   return ret;
5523 }
5524
5525
5526 #ifndef HAVE_atomic_clear
5527 # define HAVE_atomic_clear 0
5528 # define gen_atomic_clear(x,y) (gcc_unreachable (), NULL_RTX)
5529 #endif
5530
5531 /* Expand an atomic clear operation.
5532         void _atomic_clear (BOOL *obj, enum memmodel)
5533    EXP is the call expression.  */
5534
5535 static rtx
5536 expand_builtin_atomic_clear (tree exp)
5537 {
5538   enum machine_mode mode;
5539   rtx mem, ret;
5540   enum memmodel model;
5541
5542   mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0);
5543   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5544   model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5545
5546   if ((model & MEMMODEL_MASK) == MEMMODEL_ACQUIRE
5547       || (model & MEMMODEL_MASK) == MEMMODEL_ACQ_REL)
5548     {
5549       error ("invalid memory model for %<__atomic_store%>");
5550       return const0_rtx;
5551     }
5552
5553   if (HAVE_atomic_clear)
5554     {
5555       emit_insn (gen_atomic_clear (mem, model));
5556       return const0_rtx;
5557     }
5558
5559   /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release.
5560      Failing that, a store is issued by __atomic_store.  The only way this can
5561      fail is if the bool type is larger than a word size.  Unlikely, but
5562      handle it anyway for completeness.  Assume a single threaded model since
5563      there is no atomic support in this case, and no barriers are required.  */
5564   ret = expand_atomic_store (mem, const0_rtx, model, true);
5565   if (!ret)
5566     emit_move_insn (mem, const0_rtx);
5567   return const0_rtx;
5568 }
5569
5570 /* Expand an atomic test_and_set operation.
5571         bool _atomic_test_and_set (BOOL *obj, enum memmodel)
5572    EXP is the call expression.  */
5573
5574 static rtx
5575 expand_builtin_atomic_test_and_set (tree exp, rtx target)
5576 {
5577   rtx mem;
5578   enum memmodel model;
5579   enum machine_mode mode;
5580
5581   mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0);
5582   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5583   model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5584
5585   return expand_atomic_test_and_set (target, mem, model);
5586 }
5587
5588
5589 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on
5590    this architecture.  If ARG1 is NULL, use typical alignment for size ARG0.  */
5591
5592 static tree
5593 fold_builtin_atomic_always_lock_free (tree arg0, tree arg1)
5594 {
5595   int size;
5596   enum machine_mode mode;
5597   unsigned int mode_align, type_align;
5598
5599   if (TREE_CODE (arg0) != INTEGER_CST)
5600     return NULL_TREE;
5601
5602   size = INTVAL (expand_normal (arg0)) * BITS_PER_UNIT;
5603   mode = mode_for_size (size, MODE_INT, 0);
5604   mode_align = GET_MODE_ALIGNMENT (mode);
5605
5606   if (TREE_CODE (arg1) == INTEGER_CST && INTVAL (expand_normal (arg1)) == 0)
5607     type_align = mode_align;
5608   else
5609     {
5610       tree ttype = TREE_TYPE (arg1);
5611
5612       /* This function is usually invoked and folded immediately by the front
5613          end before anything else has a chance to look at it.  The pointer
5614          parameter at this point is usually cast to a void *, so check for that
5615          and look past the cast.  */
5616       if (TREE_CODE (arg1) == NOP_EXPR && POINTER_TYPE_P (ttype)
5617           && VOID_TYPE_P (TREE_TYPE (ttype)))
5618         arg1 = TREE_OPERAND (arg1, 0);
5619
5620       ttype = TREE_TYPE (arg1);
5621       gcc_assert (POINTER_TYPE_P (ttype));
5622
5623       /* Get the underlying type of the object.  */
5624       ttype = TREE_TYPE (ttype);
5625       type_align = TYPE_ALIGN (ttype);
5626     }
5627
5628   /* If the object has smaller alignment, the the lock free routines cannot
5629      be used.  */
5630   if (type_align < mode_align)
5631     return boolean_false_node;
5632
5633   /* Check if a compare_and_swap pattern exists for the mode which represents
5634      the required size.  The pattern is not allowed to fail, so the existence
5635      of the pattern indicates support is present.  */
5636   if (can_compare_and_swap_p (mode, true))
5637     return boolean_true_node;
5638   else
5639     return boolean_false_node;
5640 }
5641
5642 /* Return true if the parameters to call EXP represent an object which will
5643    always generate lock free instructions.  The first argument represents the
5644    size of the object, and the second parameter is a pointer to the object
5645    itself.  If NULL is passed for the object, then the result is based on
5646    typical alignment for an object of the specified size.  Otherwise return
5647    false.  */
5648
5649 static rtx
5650 expand_builtin_atomic_always_lock_free (tree exp)
5651 {
5652   tree size;
5653   tree arg0 = CALL_EXPR_ARG (exp, 0);
5654   tree arg1 = CALL_EXPR_ARG (exp, 1);
5655
5656   if (TREE_CODE (arg0) != INTEGER_CST)
5657     {
5658       error ("non-constant argument 1 to __atomic_always_lock_free");
5659       return const0_rtx;
5660     }
5661
5662   size = fold_builtin_atomic_always_lock_free (arg0, arg1);
5663   if (size == boolean_true_node)
5664     return const1_rtx;
5665   return const0_rtx;
5666 }
5667
5668 /* Return a one or zero if it can be determined that object ARG1 of size ARG
5669    is lock free on this architecture.  */
5670
5671 static tree
5672 fold_builtin_atomic_is_lock_free (tree arg0, tree arg1)
5673 {
5674   if (!flag_inline_atomics)
5675     return NULL_TREE;
5676
5677   /* If it isn't always lock free, don't generate a result.  */
5678   if (fold_builtin_atomic_always_lock_free (arg0, arg1) == boolean_true_node)
5679     return boolean_true_node;
5680
5681   return NULL_TREE;
5682 }
5683
5684 /* Return true if the parameters to call EXP represent an object which will
5685    always generate lock free instructions.  The first argument represents the
5686    size of the object, and the second parameter is a pointer to the object
5687    itself.  If NULL is passed for the object, then the result is based on
5688    typical alignment for an object of the specified size.  Otherwise return
5689    NULL*/
5690
5691 static rtx
5692 expand_builtin_atomic_is_lock_free (tree exp)
5693 {
5694   tree size;
5695   tree arg0 = CALL_EXPR_ARG (exp, 0);
5696   tree arg1 = CALL_EXPR_ARG (exp, 1);
5697
5698   if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
5699     {
5700       error ("non-integer argument 1 to __atomic_is_lock_free");
5701       return NULL_RTX;
5702     }
5703
5704   if (!flag_inline_atomics)
5705     return NULL_RTX;
5706
5707   /* If the value is known at compile time, return the RTX for it.  */
5708   size = fold_builtin_atomic_is_lock_free (arg0, arg1);
5709   if (size == boolean_true_node)
5710     return const1_rtx;
5711
5712   return NULL_RTX;
5713 }
5714
5715 /* Expand the __atomic_thread_fence intrinsic:
5716         void __atomic_thread_fence (enum memmodel)
5717    EXP is the CALL_EXPR.  */
5718
5719 static void
5720 expand_builtin_atomic_thread_fence (tree exp)
5721 {
5722   enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0));
5723   expand_mem_thread_fence (model);
5724 }
5725
5726 /* Expand the __atomic_signal_fence intrinsic:
5727         void __atomic_signal_fence (enum memmodel)
5728    EXP is the CALL_EXPR.  */
5729
5730 static void
5731 expand_builtin_atomic_signal_fence (tree exp)
5732 {
5733   enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0));
5734   expand_mem_signal_fence (model);
5735 }
5736
5737 /* Expand the __sync_synchronize intrinsic.  */
5738
5739 static void
5740 expand_builtin_sync_synchronize (void)
5741 {
5742   expand_mem_thread_fence (MEMMODEL_SEQ_CST);
5743 }
5744
5745 \f
5746 /* Expand an expression EXP that calls a built-in function,
5747    with result going to TARGET if that's convenient
5748    (and in mode MODE if that's convenient).
5749    SUBTARGET may be used as the target for computing one of EXP's operands.
5750    IGNORE is nonzero if the value is to be ignored.  */
5751
5752 rtx
5753 expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode,
5754                 int ignore)
5755 {
5756   tree fndecl = get_callee_fndecl (exp);
5757   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5758   enum machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5759   int flags;
5760
5761   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5762     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5763
5764   /* When not optimizing, generate calls to library functions for a certain
5765      set of builtins.  */
5766   if (!optimize
5767       && !called_as_built_in (fndecl)
5768       && fcode != BUILT_IN_ALLOCA
5769       && fcode != BUILT_IN_ALLOCA_WITH_ALIGN
5770       && fcode != BUILT_IN_FREE)
5771     return expand_call (exp, target, ignore);
5772
5773   /* The built-in function expanders test for target == const0_rtx
5774      to determine whether the function's result will be ignored.  */
5775   if (ignore)
5776     target = const0_rtx;
5777
5778   /* If the result of a pure or const built-in function is ignored, and
5779      none of its arguments are volatile, we can avoid expanding the
5780      built-in call and just evaluate the arguments for side-effects.  */
5781   if (target == const0_rtx
5782       && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5783       && !(flags & ECF_LOOPING_CONST_OR_PURE))
5784     {
5785       bool volatilep = false;
5786       tree arg;
5787       call_expr_arg_iterator iter;
5788
5789       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5790         if (TREE_THIS_VOLATILE (arg))
5791           {
5792             volatilep = true;
5793             break;
5794           }
5795
5796       if (! volatilep)
5797         {
5798           FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5799             expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5800           return const0_rtx;
5801         }
5802     }
5803
5804   switch (fcode)
5805     {
5806     CASE_FLT_FN (BUILT_IN_FABS):
5807       target = expand_builtin_fabs (exp, target, subtarget);
5808       if (target)
5809         return target;
5810       break;
5811
5812     CASE_FLT_FN (BUILT_IN_COPYSIGN):
5813       target = expand_builtin_copysign (exp, target, subtarget);
5814       if (target)
5815         return target;
5816       break;
5817
5818       /* Just do a normal library call if we were unable to fold
5819          the values.  */
5820     CASE_FLT_FN (BUILT_IN_CABS):
5821       break;
5822
5823     CASE_FLT_FN (BUILT_IN_EXP):
5824     CASE_FLT_FN (BUILT_IN_EXP10):
5825     CASE_FLT_FN (BUILT_IN_POW10):
5826     CASE_FLT_FN (BUILT_IN_EXP2):
5827     CASE_FLT_FN (BUILT_IN_EXPM1):
5828     CASE_FLT_FN (BUILT_IN_LOGB):
5829     CASE_FLT_FN (BUILT_IN_LOG):
5830     CASE_FLT_FN (BUILT_IN_LOG10):
5831     CASE_FLT_FN (BUILT_IN_LOG2):
5832     CASE_FLT_FN (BUILT_IN_LOG1P):
5833     CASE_FLT_FN (BUILT_IN_TAN):
5834     CASE_FLT_FN (BUILT_IN_ASIN):
5835     CASE_FLT_FN (BUILT_IN_ACOS):
5836     CASE_FLT_FN (BUILT_IN_ATAN):
5837     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
5838       /* Treat these like sqrt only if unsafe math optimizations are allowed,
5839          because of possible accuracy problems.  */
5840       if (! flag_unsafe_math_optimizations)
5841         break;
5842     CASE_FLT_FN (BUILT_IN_SQRT):
5843     CASE_FLT_FN (BUILT_IN_FLOOR):
5844     CASE_FLT_FN (BUILT_IN_CEIL):
5845     CASE_FLT_FN (BUILT_IN_TRUNC):
5846     CASE_FLT_FN (BUILT_IN_ROUND):
5847     CASE_FLT_FN (BUILT_IN_NEARBYINT):
5848     CASE_FLT_FN (BUILT_IN_RINT):
5849       target = expand_builtin_mathfn (exp, target, subtarget);
5850       if (target)
5851         return target;
5852       break;
5853
5854     CASE_FLT_FN (BUILT_IN_FMA):
5855       target = expand_builtin_mathfn_ternary (exp, target, subtarget);
5856       if (target)
5857         return target;
5858       break;
5859
5860     CASE_FLT_FN (BUILT_IN_ILOGB):
5861       if (! flag_unsafe_math_optimizations)
5862         break;
5863     CASE_FLT_FN (BUILT_IN_ISINF):
5864     CASE_FLT_FN (BUILT_IN_FINITE):
5865     case BUILT_IN_ISFINITE:
5866     case BUILT_IN_ISNORMAL:
5867       target = expand_builtin_interclass_mathfn (exp, target);
5868       if (target)
5869         return target;
5870       break;
5871
5872     CASE_FLT_FN (BUILT_IN_ICEIL):
5873     CASE_FLT_FN (BUILT_IN_LCEIL):
5874     CASE_FLT_FN (BUILT_IN_LLCEIL):
5875     CASE_FLT_FN (BUILT_IN_LFLOOR):
5876     CASE_FLT_FN (BUILT_IN_IFLOOR):
5877     CASE_FLT_FN (BUILT_IN_LLFLOOR):
5878       target = expand_builtin_int_roundingfn (exp, target);
5879       if (target)
5880         return target;
5881       break;
5882
5883     CASE_FLT_FN (BUILT_IN_IRINT):
5884     CASE_FLT_FN (BUILT_IN_LRINT):
5885     CASE_FLT_FN (BUILT_IN_LLRINT):
5886     CASE_FLT_FN (BUILT_IN_IROUND):
5887     CASE_FLT_FN (BUILT_IN_LROUND):
5888     CASE_FLT_FN (BUILT_IN_LLROUND):
5889       target = expand_builtin_int_roundingfn_2 (exp, target);
5890       if (target)
5891         return target;
5892       break;
5893
5894     CASE_FLT_FN (BUILT_IN_POWI):
5895       target = expand_builtin_powi (exp, target);
5896       if (target)
5897         return target;
5898       break;
5899
5900     CASE_FLT_FN (BUILT_IN_ATAN2):
5901     CASE_FLT_FN (BUILT_IN_LDEXP):
5902     CASE_FLT_FN (BUILT_IN_SCALB):
5903     CASE_FLT_FN (BUILT_IN_SCALBN):
5904     CASE_FLT_FN (BUILT_IN_SCALBLN):
5905       if (! flag_unsafe_math_optimizations)
5906         break;
5907
5908     CASE_FLT_FN (BUILT_IN_FMOD):
5909     CASE_FLT_FN (BUILT_IN_REMAINDER):
5910     CASE_FLT_FN (BUILT_IN_DREM):
5911     CASE_FLT_FN (BUILT_IN_POW):
5912       target = expand_builtin_mathfn_2 (exp, target, subtarget);
5913       if (target)
5914         return target;
5915       break;
5916
5917     CASE_FLT_FN (BUILT_IN_CEXPI):
5918       target = expand_builtin_cexpi (exp, target);
5919       gcc_assert (target);
5920       return target;
5921
5922     CASE_FLT_FN (BUILT_IN_SIN):
5923     CASE_FLT_FN (BUILT_IN_COS):
5924       if (! flag_unsafe_math_optimizations)
5925         break;
5926       target = expand_builtin_mathfn_3 (exp, target, subtarget);
5927       if (target)
5928         return target;
5929       break;
5930
5931     CASE_FLT_FN (BUILT_IN_SINCOS):
5932       if (! flag_unsafe_math_optimizations)
5933         break;
5934       target = expand_builtin_sincos (exp);
5935       if (target)
5936         return target;
5937       break;
5938
5939     case BUILT_IN_APPLY_ARGS:
5940       return expand_builtin_apply_args ();
5941
5942       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5943          FUNCTION with a copy of the parameters described by
5944          ARGUMENTS, and ARGSIZE.  It returns a block of memory
5945          allocated on the stack into which is stored all the registers
5946          that might possibly be used for returning the result of a
5947          function.  ARGUMENTS is the value returned by
5948          __builtin_apply_args.  ARGSIZE is the number of bytes of
5949          arguments that must be copied.  ??? How should this value be
5950          computed?  We'll also need a safe worst case value for varargs
5951          functions.  */
5952     case BUILT_IN_APPLY:
5953       if (!validate_arglist (exp, POINTER_TYPE,
5954                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5955           && !validate_arglist (exp, REFERENCE_TYPE,
5956                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5957         return const0_rtx;
5958       else
5959         {
5960           rtx ops[3];
5961
5962           ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
5963           ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
5964           ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
5965
5966           return expand_builtin_apply (ops[0], ops[1], ops[2]);
5967         }
5968
5969       /* __builtin_return (RESULT) causes the function to return the
5970          value described by RESULT.  RESULT is address of the block of
5971          memory returned by __builtin_apply.  */
5972     case BUILT_IN_RETURN:
5973       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5974         expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
5975       return const0_rtx;
5976
5977     case BUILT_IN_SAVEREGS:
5978       return expand_builtin_saveregs ();
5979
5980     case BUILT_IN_VA_ARG_PACK:
5981       /* All valid uses of __builtin_va_arg_pack () are removed during
5982          inlining.  */
5983       error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
5984       return const0_rtx;
5985
5986     case BUILT_IN_VA_ARG_PACK_LEN:
5987       /* All valid uses of __builtin_va_arg_pack_len () are removed during
5988          inlining.  */
5989       error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
5990       return const0_rtx;
5991
5992       /* Return the address of the first anonymous stack arg.  */
5993     case BUILT_IN_NEXT_ARG:
5994       if (fold_builtin_next_arg (exp, false))
5995         return const0_rtx;
5996       return expand_builtin_next_arg ();
5997
5998     case BUILT_IN_CLEAR_CACHE:
5999       target = expand_builtin___clear_cache (exp);
6000       if (target)
6001         return target;
6002       break;
6003
6004     case BUILT_IN_CLASSIFY_TYPE:
6005       return expand_builtin_classify_type (exp);
6006
6007     case BUILT_IN_CONSTANT_P:
6008       return const0_rtx;
6009
6010     case BUILT_IN_FRAME_ADDRESS:
6011     case BUILT_IN_RETURN_ADDRESS:
6012       return expand_builtin_frame_address (fndecl, exp);
6013
6014     /* Returns the address of the area where the structure is returned.
6015        0 otherwise.  */
6016     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
6017       if (call_expr_nargs (exp) != 0
6018           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
6019           || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
6020         return const0_rtx;
6021       else
6022         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
6023
6024     case BUILT_IN_ALLOCA:
6025     case BUILT_IN_ALLOCA_WITH_ALIGN:
6026       /* If the allocation stems from the declaration of a variable-sized
6027          object, it cannot accumulate.  */
6028       target = expand_builtin_alloca (exp, CALL_ALLOCA_FOR_VAR_P (exp));
6029       if (target)
6030         return target;
6031       break;
6032
6033     case BUILT_IN_STACK_SAVE:
6034       return expand_stack_save ();
6035
6036     case BUILT_IN_STACK_RESTORE:
6037       expand_stack_restore (CALL_EXPR_ARG (exp, 0));
6038       return const0_rtx;
6039
6040     case BUILT_IN_BSWAP16:
6041     case BUILT_IN_BSWAP32:
6042     case BUILT_IN_BSWAP64:
6043       target = expand_builtin_bswap (target_mode, exp, target, subtarget);
6044       if (target)
6045         return target;
6046       break;
6047
6048     CASE_INT_FN (BUILT_IN_FFS):
6049     case BUILT_IN_FFSIMAX:
6050       target = expand_builtin_unop (target_mode, exp, target,
6051                                     subtarget, ffs_optab);
6052       if (target)
6053         return target;
6054       break;
6055
6056     CASE_INT_FN (BUILT_IN_CLZ):
6057     case BUILT_IN_CLZIMAX:
6058       target = expand_builtin_unop (target_mode, exp, target,
6059                                     subtarget, clz_optab);
6060       if (target)
6061         return target;
6062       break;
6063
6064     CASE_INT_FN (BUILT_IN_CTZ):
6065     case BUILT_IN_CTZIMAX:
6066       target = expand_builtin_unop (target_mode, exp, target,
6067                                     subtarget, ctz_optab);
6068       if (target)
6069         return target;
6070       break;
6071
6072     CASE_INT_FN (BUILT_IN_CLRSB):
6073     case BUILT_IN_CLRSBIMAX:
6074       target = expand_builtin_unop (target_mode, exp, target,
6075                                     subtarget, clrsb_optab);
6076       if (target)
6077         return target;
6078       break;
6079
6080     CASE_INT_FN (BUILT_IN_POPCOUNT):
6081     case BUILT_IN_POPCOUNTIMAX:
6082       target = expand_builtin_unop (target_mode, exp, target,
6083                                     subtarget, popcount_optab);
6084       if (target)
6085         return target;
6086       break;
6087
6088     CASE_INT_FN (BUILT_IN_PARITY):
6089     case BUILT_IN_PARITYIMAX:
6090       target = expand_builtin_unop (target_mode, exp, target,
6091                                     subtarget, parity_optab);
6092       if (target)
6093         return target;
6094       break;
6095
6096     case BUILT_IN_STRLEN:
6097       target = expand_builtin_strlen (exp, target, target_mode);
6098       if (target)
6099         return target;
6100       break;
6101
6102     case BUILT_IN_STRCPY:
6103       target = expand_builtin_strcpy (exp, target);
6104       if (target)
6105         return target;
6106       break;
6107
6108     case BUILT_IN_STRNCPY:
6109       target = expand_builtin_strncpy (exp, target);
6110       if (target)
6111         return target;
6112       break;
6113
6114     case BUILT_IN_STPCPY:
6115       target = expand_builtin_stpcpy (exp, target, mode);
6116       if (target)
6117         return target;
6118       break;
6119
6120     case BUILT_IN_MEMCPY:
6121       target = expand_builtin_memcpy (exp, target);
6122       if (target)
6123         return target;
6124       break;
6125
6126     case BUILT_IN_MEMPCPY:
6127       target = expand_builtin_mempcpy (exp, target, mode);
6128       if (target)
6129         return target;
6130       break;
6131
6132     case BUILT_IN_MEMSET:
6133       target = expand_builtin_memset (exp, target, mode);
6134       if (target)
6135         return target;
6136       break;
6137
6138     case BUILT_IN_BZERO:
6139       target = expand_builtin_bzero (exp);
6140       if (target)
6141         return target;
6142       break;
6143
6144     case BUILT_IN_STRCMP:
6145       target = expand_builtin_strcmp (exp, target);
6146       if (target)
6147         return target;
6148       break;
6149
6150     case BUILT_IN_STRNCMP:
6151       target = expand_builtin_strncmp (exp, target, mode);
6152       if (target)
6153         return target;
6154       break;
6155
6156     case BUILT_IN_BCMP:
6157     case BUILT_IN_MEMCMP:
6158       target = expand_builtin_memcmp (exp, target, mode);
6159       if (target)
6160         return target;
6161       break;
6162
6163     case BUILT_IN_SETJMP:
6164       /* This should have been lowered to the builtins below.  */
6165       gcc_unreachable ();
6166
6167     case BUILT_IN_SETJMP_SETUP:
6168       /* __builtin_setjmp_setup is passed a pointer to an array of five words
6169           and the receiver label.  */
6170       if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6171         {
6172           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6173                                       VOIDmode, EXPAND_NORMAL);
6174           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6175           rtx label_r = label_rtx (label);
6176
6177           /* This is copied from the handling of non-local gotos.  */
6178           expand_builtin_setjmp_setup (buf_addr, label_r);
6179           nonlocal_goto_handler_labels
6180             = gen_rtx_EXPR_LIST (VOIDmode, label_r,
6181                                  nonlocal_goto_handler_labels);
6182           /* ??? Do not let expand_label treat us as such since we would
6183              not want to be both on the list of non-local labels and on
6184              the list of forced labels.  */
6185           FORCED_LABEL (label) = 0;
6186           return const0_rtx;
6187         }
6188       break;
6189
6190     case BUILT_IN_SETJMP_DISPATCHER:
6191        /* __builtin_setjmp_dispatcher is passed the dispatcher label.  */
6192       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6193         {
6194           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6195           rtx label_r = label_rtx (label);
6196
6197           /* Remove the dispatcher label from the list of non-local labels
6198              since the receiver labels have been added to it above.  */
6199           remove_node_from_expr_list (label_r, &nonlocal_goto_handler_labels);
6200           return const0_rtx;
6201         }
6202       break;
6203
6204     case BUILT_IN_SETJMP_RECEIVER:
6205        /* __builtin_setjmp_receiver is passed the receiver label.  */
6206       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6207         {
6208           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6209           rtx label_r = label_rtx (label);
6210
6211           expand_builtin_setjmp_receiver (label_r);
6212           return const0_rtx;
6213         }
6214       break;
6215
6216       /* __builtin_longjmp is passed a pointer to an array of five words.
6217          It's similar to the C library longjmp function but works with
6218          __builtin_setjmp above.  */
6219     case BUILT_IN_LONGJMP:
6220       if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6221         {
6222           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6223                                       VOIDmode, EXPAND_NORMAL);
6224           rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6225
6226           if (value != const1_rtx)
6227             {
6228               error ("%<__builtin_longjmp%> second argument must be 1");
6229               return const0_rtx;
6230             }
6231
6232           expand_builtin_longjmp (buf_addr, value);
6233           return const0_rtx;
6234         }
6235       break;
6236
6237     case BUILT_IN_NONLOCAL_GOTO:
6238       target = expand_builtin_nonlocal_goto (exp);
6239       if (target)
6240         return target;
6241       break;
6242
6243       /* This updates the setjmp buffer that is its argument with the value
6244          of the current stack pointer.  */
6245     case BUILT_IN_UPDATE_SETJMP_BUF:
6246       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6247         {
6248           rtx buf_addr
6249             = expand_normal (CALL_EXPR_ARG (exp, 0));
6250
6251           expand_builtin_update_setjmp_buf (buf_addr);
6252           return const0_rtx;
6253         }
6254       break;
6255
6256     case BUILT_IN_TRAP:
6257       expand_builtin_trap ();
6258       return const0_rtx;
6259
6260     case BUILT_IN_UNREACHABLE:
6261       expand_builtin_unreachable ();
6262       return const0_rtx;
6263
6264     CASE_FLT_FN (BUILT_IN_SIGNBIT):
6265     case BUILT_IN_SIGNBITD32:
6266     case BUILT_IN_SIGNBITD64:
6267     case BUILT_IN_SIGNBITD128:
6268       target = expand_builtin_signbit (exp, target);
6269       if (target)
6270         return target;
6271       break;
6272
6273       /* Various hooks for the DWARF 2 __throw routine.  */
6274     case BUILT_IN_UNWIND_INIT:
6275       expand_builtin_unwind_init ();
6276       return const0_rtx;
6277     case BUILT_IN_DWARF_CFA:
6278       return virtual_cfa_rtx;
6279 #ifdef DWARF2_UNWIND_INFO
6280     case BUILT_IN_DWARF_SP_COLUMN:
6281       return expand_builtin_dwarf_sp_column ();
6282     case BUILT_IN_INIT_DWARF_REG_SIZES:
6283       expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6284       return const0_rtx;
6285 #endif
6286     case BUILT_IN_FROB_RETURN_ADDR:
6287       return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6288     case BUILT_IN_EXTRACT_RETURN_ADDR:
6289       return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6290     case BUILT_IN_EH_RETURN:
6291       expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6292                                 CALL_EXPR_ARG (exp, 1));
6293       return const0_rtx;
6294 #ifdef EH_RETURN_DATA_REGNO
6295     case BUILT_IN_EH_RETURN_DATA_REGNO:
6296       return expand_builtin_eh_return_data_regno (exp);
6297 #endif
6298     case BUILT_IN_EXTEND_POINTER:
6299       return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6300     case BUILT_IN_EH_POINTER:
6301       return expand_builtin_eh_pointer (exp);
6302     case BUILT_IN_EH_FILTER:
6303       return expand_builtin_eh_filter (exp);
6304     case BUILT_IN_EH_COPY_VALUES:
6305       return expand_builtin_eh_copy_values (exp);
6306
6307     case BUILT_IN_VA_START:
6308       return expand_builtin_va_start (exp);
6309     case BUILT_IN_VA_END:
6310       return expand_builtin_va_end (exp);
6311     case BUILT_IN_VA_COPY:
6312       return expand_builtin_va_copy (exp);
6313     case BUILT_IN_EXPECT:
6314       return expand_builtin_expect (exp, target);
6315     case BUILT_IN_ASSUME_ALIGNED:
6316       return expand_builtin_assume_aligned (exp, target);
6317     case BUILT_IN_PREFETCH:
6318       expand_builtin_prefetch (exp);
6319       return const0_rtx;
6320
6321     case BUILT_IN_INIT_TRAMPOLINE:
6322       return expand_builtin_init_trampoline (exp, true);
6323     case BUILT_IN_INIT_HEAP_TRAMPOLINE:
6324       return expand_builtin_init_trampoline (exp, false);
6325     case BUILT_IN_ADJUST_TRAMPOLINE:
6326       return expand_builtin_adjust_trampoline (exp);
6327
6328     case BUILT_IN_FORK:
6329     case BUILT_IN_EXECL:
6330     case BUILT_IN_EXECV:
6331     case BUILT_IN_EXECLP:
6332     case BUILT_IN_EXECLE:
6333     case BUILT_IN_EXECVP:
6334     case BUILT_IN_EXECVE:
6335       target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6336       if (target)
6337         return target;
6338       break;
6339
6340     case BUILT_IN_SYNC_FETCH_AND_ADD_1:
6341     case BUILT_IN_SYNC_FETCH_AND_ADD_2:
6342     case BUILT_IN_SYNC_FETCH_AND_ADD_4:
6343     case BUILT_IN_SYNC_FETCH_AND_ADD_8:
6344     case BUILT_IN_SYNC_FETCH_AND_ADD_16:
6345       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_ADD_1);
6346       target = expand_builtin_sync_operation (mode, exp, PLUS, false, target);
6347       if (target)
6348         return target;
6349       break;
6350
6351     case BUILT_IN_SYNC_FETCH_AND_SUB_1:
6352     case BUILT_IN_SYNC_FETCH_AND_SUB_2:
6353     case BUILT_IN_SYNC_FETCH_AND_SUB_4:
6354     case BUILT_IN_SYNC_FETCH_AND_SUB_8:
6355     case BUILT_IN_SYNC_FETCH_AND_SUB_16:
6356       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_SUB_1);
6357       target = expand_builtin_sync_operation (mode, exp, MINUS, false, target);
6358       if (target)
6359         return target;
6360       break;
6361
6362     case BUILT_IN_SYNC_FETCH_AND_OR_1:
6363     case BUILT_IN_SYNC_FETCH_AND_OR_2:
6364     case BUILT_IN_SYNC_FETCH_AND_OR_4:
6365     case BUILT_IN_SYNC_FETCH_AND_OR_8:
6366     case BUILT_IN_SYNC_FETCH_AND_OR_16:
6367       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_OR_1);
6368       target = expand_builtin_sync_operation (mode, exp, IOR, false, target);
6369       if (target)
6370         return target;
6371       break;
6372
6373     case BUILT_IN_SYNC_FETCH_AND_AND_1:
6374     case BUILT_IN_SYNC_FETCH_AND_AND_2:
6375     case BUILT_IN_SYNC_FETCH_AND_AND_4:
6376     case BUILT_IN_SYNC_FETCH_AND_AND_8:
6377     case BUILT_IN_SYNC_FETCH_AND_AND_16:
6378       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_AND_1);
6379       target = expand_builtin_sync_operation (mode, exp, AND, false, target);
6380       if (target)
6381         return target;
6382       break;
6383
6384     case BUILT_IN_SYNC_FETCH_AND_XOR_1:
6385     case BUILT_IN_SYNC_FETCH_AND_XOR_2:
6386     case BUILT_IN_SYNC_FETCH_AND_XOR_4:
6387     case BUILT_IN_SYNC_FETCH_AND_XOR_8:
6388     case BUILT_IN_SYNC_FETCH_AND_XOR_16:
6389       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_XOR_1);
6390       target = expand_builtin_sync_operation (mode, exp, XOR, false, target);
6391       if (target)
6392         return target;
6393       break;
6394
6395     case BUILT_IN_SYNC_FETCH_AND_NAND_1:
6396     case BUILT_IN_SYNC_FETCH_AND_NAND_2:
6397     case BUILT_IN_SYNC_FETCH_AND_NAND_4:
6398     case BUILT_IN_SYNC_FETCH_AND_NAND_8:
6399     case BUILT_IN_SYNC_FETCH_AND_NAND_16:
6400       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_NAND_1);
6401       target = expand_builtin_sync_operation (mode, exp, NOT, false, target);
6402       if (target)
6403         return target;
6404       break;
6405
6406     case BUILT_IN_SYNC_ADD_AND_FETCH_1:
6407     case BUILT_IN_SYNC_ADD_AND_FETCH_2:
6408     case BUILT_IN_SYNC_ADD_AND_FETCH_4:
6409     case BUILT_IN_SYNC_ADD_AND_FETCH_8:
6410     case BUILT_IN_SYNC_ADD_AND_FETCH_16:
6411       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_ADD_AND_FETCH_1);
6412       target = expand_builtin_sync_operation (mode, exp, PLUS, true, target);
6413       if (target)
6414         return target;
6415       break;
6416
6417     case BUILT_IN_SYNC_SUB_AND_FETCH_1:
6418     case BUILT_IN_SYNC_SUB_AND_FETCH_2:
6419     case BUILT_IN_SYNC_SUB_AND_FETCH_4:
6420     case BUILT_IN_SYNC_SUB_AND_FETCH_8:
6421     case BUILT_IN_SYNC_SUB_AND_FETCH_16:
6422       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_SUB_AND_FETCH_1);
6423       target = expand_builtin_sync_operation (mode, exp, MINUS, true, target);
6424       if (target)
6425         return target;
6426       break;
6427
6428     case BUILT_IN_SYNC_OR_AND_FETCH_1:
6429     case BUILT_IN_SYNC_OR_AND_FETCH_2:
6430     case BUILT_IN_SYNC_OR_AND_FETCH_4:
6431     case BUILT_IN_SYNC_OR_AND_FETCH_8:
6432     case BUILT_IN_SYNC_OR_AND_FETCH_16:
6433       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_OR_AND_FETCH_1);
6434       target = expand_builtin_sync_operation (mode, exp, IOR, true, target);
6435       if (target)
6436         return target;
6437       break;
6438
6439     case BUILT_IN_SYNC_AND_AND_FETCH_1:
6440     case BUILT_IN_SYNC_AND_AND_FETCH_2:
6441     case BUILT_IN_SYNC_AND_AND_FETCH_4:
6442     case BUILT_IN_SYNC_AND_AND_FETCH_8:
6443     case BUILT_IN_SYNC_AND_AND_FETCH_16:
6444       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_AND_AND_FETCH_1);
6445       target = expand_builtin_sync_operation (mode, exp, AND, true, target);
6446       if (target)
6447         return target;
6448       break;
6449
6450     case BUILT_IN_SYNC_XOR_AND_FETCH_1:
6451     case BUILT_IN_SYNC_XOR_AND_FETCH_2:
6452     case BUILT_IN_SYNC_XOR_AND_FETCH_4:
6453     case BUILT_IN_SYNC_XOR_AND_FETCH_8:
6454     case BUILT_IN_SYNC_XOR_AND_FETCH_16:
6455       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_XOR_AND_FETCH_1);
6456       target = expand_builtin_sync_operation (mode, exp, XOR, true, target);
6457       if (target)
6458         return target;
6459       break;
6460
6461     case BUILT_IN_SYNC_NAND_AND_FETCH_1:
6462     case BUILT_IN_SYNC_NAND_AND_FETCH_2:
6463     case BUILT_IN_SYNC_NAND_AND_FETCH_4:
6464     case BUILT_IN_SYNC_NAND_AND_FETCH_8:
6465     case BUILT_IN_SYNC_NAND_AND_FETCH_16:
6466       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_NAND_AND_FETCH_1);
6467       target = expand_builtin_sync_operation (mode, exp, NOT, true, target);
6468       if (target)
6469         return target;
6470       break;
6471
6472     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1:
6473     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2:
6474     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4:
6475     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8:
6476     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16:
6477       if (mode == VOIDmode)
6478         mode = TYPE_MODE (boolean_type_node);
6479       if (!target || !register_operand (target, mode))
6480         target = gen_reg_rtx (mode);
6481
6482       mode = get_builtin_sync_mode
6483                                 (fcode - BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1);
6484       target = expand_builtin_compare_and_swap (mode, exp, true, target);
6485       if (target)
6486         return target;
6487       break;
6488
6489     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1:
6490     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2:
6491     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4:
6492     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8:
6493     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16:
6494       mode = get_builtin_sync_mode
6495                                 (fcode - BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1);
6496       target = expand_builtin_compare_and_swap (mode, exp, false, target);
6497       if (target)
6498         return target;
6499       break;
6500
6501     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1:
6502     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2:
6503     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4:
6504     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8:
6505     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16:
6506       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_TEST_AND_SET_1);
6507       target = expand_builtin_sync_lock_test_and_set (mode, exp, target);
6508       if (target)
6509         return target;
6510       break;
6511
6512     case BUILT_IN_SYNC_LOCK_RELEASE_1:
6513     case BUILT_IN_SYNC_LOCK_RELEASE_2:
6514     case BUILT_IN_SYNC_LOCK_RELEASE_4:
6515     case BUILT_IN_SYNC_LOCK_RELEASE_8:
6516     case BUILT_IN_SYNC_LOCK_RELEASE_16:
6517       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_RELEASE_1);
6518       expand_builtin_sync_lock_release (mode, exp);
6519       return const0_rtx;
6520
6521     case BUILT_IN_SYNC_SYNCHRONIZE:
6522       expand_builtin_sync_synchronize ();
6523       return const0_rtx;
6524
6525     case BUILT_IN_ATOMIC_EXCHANGE_1:
6526     case BUILT_IN_ATOMIC_EXCHANGE_2:
6527     case BUILT_IN_ATOMIC_EXCHANGE_4:
6528     case BUILT_IN_ATOMIC_EXCHANGE_8:
6529     case BUILT_IN_ATOMIC_EXCHANGE_16:
6530       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_EXCHANGE_1);
6531       target = expand_builtin_atomic_exchange (mode, exp, target);
6532       if (target)
6533         return target;
6534       break;
6535
6536     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1:
6537     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2:
6538     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4:
6539     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8:
6540     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16:
6541       {
6542         unsigned int nargs, z;
6543         VEC(tree,gc) *vec;
6544
6545         mode =
6546             get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1);
6547         target = expand_builtin_atomic_compare_exchange (mode, exp, target);
6548         if (target)
6549           return target;
6550
6551         /* If this is turned into an external library call, the weak parameter
6552            must be dropped to match the expected parameter list.  */
6553         nargs = call_expr_nargs (exp);
6554         vec = VEC_alloc (tree, gc, nargs - 1);
6555         for (z = 0; z < 3; z++)
6556           VEC_quick_push (tree, vec, CALL_EXPR_ARG (exp, z));
6557         /* Skip the boolean weak parameter.  */
6558         for (z = 4; z < 6; z++)
6559           VEC_quick_push (tree, vec, CALL_EXPR_ARG (exp, z));
6560         exp = build_call_vec (TREE_TYPE (exp), CALL_EXPR_FN (exp), vec);
6561         break;
6562       }
6563
6564     case BUILT_IN_ATOMIC_LOAD_1:
6565     case BUILT_IN_ATOMIC_LOAD_2:
6566     case BUILT_IN_ATOMIC_LOAD_4:
6567     case BUILT_IN_ATOMIC_LOAD_8:
6568     case BUILT_IN_ATOMIC_LOAD_16:
6569       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_LOAD_1);
6570       target = expand_builtin_atomic_load (mode, exp, target);
6571       if (target)
6572         return target;
6573       break;
6574
6575     case BUILT_IN_ATOMIC_STORE_1:
6576     case BUILT_IN_ATOMIC_STORE_2:
6577     case BUILT_IN_ATOMIC_STORE_4:
6578     case BUILT_IN_ATOMIC_STORE_8:
6579     case BUILT_IN_ATOMIC_STORE_16:
6580       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_STORE_1);
6581       target = expand_builtin_atomic_store (mode, exp);
6582       if (target)
6583         return const0_rtx;
6584       break;
6585
6586     case BUILT_IN_ATOMIC_ADD_FETCH_1:
6587     case BUILT_IN_ATOMIC_ADD_FETCH_2:
6588     case BUILT_IN_ATOMIC_ADD_FETCH_4:
6589     case BUILT_IN_ATOMIC_ADD_FETCH_8:
6590     case BUILT_IN_ATOMIC_ADD_FETCH_16:
6591       {
6592         enum built_in_function lib;
6593         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1);
6594         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_ADD_1 +
6595                                        (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1));
6596         target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, true,
6597                                                  ignore, lib);
6598         if (target)
6599           return target;
6600         break;
6601       }
6602     case BUILT_IN_ATOMIC_SUB_FETCH_1:
6603     case BUILT_IN_ATOMIC_SUB_FETCH_2:
6604     case BUILT_IN_ATOMIC_SUB_FETCH_4:
6605     case BUILT_IN_ATOMIC_SUB_FETCH_8:
6606     case BUILT_IN_ATOMIC_SUB_FETCH_16:
6607       {
6608         enum built_in_function lib;
6609         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1);
6610         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_SUB_1 +
6611                                        (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1));
6612         target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, true,
6613                                                  ignore, lib);
6614         if (target)
6615           return target;
6616         break;
6617       }
6618     case BUILT_IN_ATOMIC_AND_FETCH_1:
6619     case BUILT_IN_ATOMIC_AND_FETCH_2:
6620     case BUILT_IN_ATOMIC_AND_FETCH_4:
6621     case BUILT_IN_ATOMIC_AND_FETCH_8:
6622     case BUILT_IN_ATOMIC_AND_FETCH_16:
6623       {
6624         enum built_in_function lib;
6625         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_AND_FETCH_1);
6626         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_AND_1 +
6627                                        (fcode - BUILT_IN_ATOMIC_AND_FETCH_1));
6628         target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, true,
6629                                                  ignore, lib);
6630         if (target)
6631           return target;
6632         break;
6633       }
6634     case BUILT_IN_ATOMIC_NAND_FETCH_1:
6635     case BUILT_IN_ATOMIC_NAND_FETCH_2:
6636     case BUILT_IN_ATOMIC_NAND_FETCH_4:
6637     case BUILT_IN_ATOMIC_NAND_FETCH_8:
6638     case BUILT_IN_ATOMIC_NAND_FETCH_16:
6639       {
6640         enum built_in_function lib;
6641         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1);
6642         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_NAND_1 +
6643                                        (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1));
6644         target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, true,
6645                                                  ignore, lib);
6646         if (target)
6647           return target;
6648         break;
6649       }
6650     case BUILT_IN_ATOMIC_XOR_FETCH_1:
6651     case BUILT_IN_ATOMIC_XOR_FETCH_2:
6652     case BUILT_IN_ATOMIC_XOR_FETCH_4:
6653     case BUILT_IN_ATOMIC_XOR_FETCH_8:
6654     case BUILT_IN_ATOMIC_XOR_FETCH_16:
6655       {
6656         enum built_in_function lib;
6657         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1);
6658         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_XOR_1 +
6659                                        (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1));
6660         target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, true,
6661                                                  ignore, lib);
6662         if (target)
6663           return target;
6664         break;
6665       }
6666     case BUILT_IN_ATOMIC_OR_FETCH_1:
6667     case BUILT_IN_ATOMIC_OR_FETCH_2:
6668     case BUILT_IN_ATOMIC_OR_FETCH_4:
6669     case BUILT_IN_ATOMIC_OR_FETCH_8:
6670     case BUILT_IN_ATOMIC_OR_FETCH_16:
6671       {
6672         enum built_in_function lib;
6673         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_OR_FETCH_1);
6674         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_OR_1 +
6675                                        (fcode - BUILT_IN_ATOMIC_OR_FETCH_1));
6676         target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, true,
6677                                                  ignore, lib);
6678         if (target)
6679           return target;
6680         break;
6681       }
6682     case BUILT_IN_ATOMIC_FETCH_ADD_1:
6683     case BUILT_IN_ATOMIC_FETCH_ADD_2:
6684     case BUILT_IN_ATOMIC_FETCH_ADD_4:
6685     case BUILT_IN_ATOMIC_FETCH_ADD_8:
6686     case BUILT_IN_ATOMIC_FETCH_ADD_16:
6687       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_ADD_1);
6688       target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, false,
6689                                                ignore, BUILT_IN_NONE);
6690       if (target)
6691         return target;
6692       break;
6693
6694     case BUILT_IN_ATOMIC_FETCH_SUB_1:
6695     case BUILT_IN_ATOMIC_FETCH_SUB_2:
6696     case BUILT_IN_ATOMIC_FETCH_SUB_4:
6697     case BUILT_IN_ATOMIC_FETCH_SUB_8:
6698     case BUILT_IN_ATOMIC_FETCH_SUB_16:
6699       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_SUB_1);
6700       target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, false,
6701                                                ignore, BUILT_IN_NONE);
6702       if (target)
6703         return target;
6704       break;
6705
6706     case BUILT_IN_ATOMIC_FETCH_AND_1:
6707     case BUILT_IN_ATOMIC_FETCH_AND_2:
6708     case BUILT_IN_ATOMIC_FETCH_AND_4:
6709     case BUILT_IN_ATOMIC_FETCH_AND_8:
6710     case BUILT_IN_ATOMIC_FETCH_AND_16:
6711       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_AND_1);
6712       target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, false,
6713                                                ignore, BUILT_IN_NONE);
6714       if (target)
6715         return target;
6716       break;
6717
6718     case BUILT_IN_ATOMIC_FETCH_NAND_1:
6719     case BUILT_IN_ATOMIC_FETCH_NAND_2:
6720     case BUILT_IN_ATOMIC_FETCH_NAND_4:
6721     case BUILT_IN_ATOMIC_FETCH_NAND_8:
6722     case BUILT_IN_ATOMIC_FETCH_NAND_16:
6723       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_NAND_1);
6724       target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, false,
6725                                                ignore, BUILT_IN_NONE);
6726       if (target)
6727         return target;
6728       break;
6729
6730     case BUILT_IN_ATOMIC_FETCH_XOR_1:
6731     case BUILT_IN_ATOMIC_FETCH_XOR_2:
6732     case BUILT_IN_ATOMIC_FETCH_XOR_4:
6733     case BUILT_IN_ATOMIC_FETCH_XOR_8:
6734     case BUILT_IN_ATOMIC_FETCH_XOR_16:
6735       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_XOR_1);
6736       target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, false,
6737                                                ignore, BUILT_IN_NONE);
6738       if (target)
6739         return target;
6740       break;
6741
6742     case BUILT_IN_ATOMIC_FETCH_OR_1:
6743     case BUILT_IN_ATOMIC_FETCH_OR_2:
6744     case BUILT_IN_ATOMIC_FETCH_OR_4:
6745     case BUILT_IN_ATOMIC_FETCH_OR_8:
6746     case BUILT_IN_ATOMIC_FETCH_OR_16:
6747       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_OR_1);
6748       target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, false,
6749                                                ignore, BUILT_IN_NONE);
6750       if (target)
6751         return target;
6752       break;
6753
6754     case BUILT_IN_ATOMIC_TEST_AND_SET:
6755       return expand_builtin_atomic_test_and_set (exp, target);
6756
6757     case BUILT_IN_ATOMIC_CLEAR:
6758       return expand_builtin_atomic_clear (exp);
6759
6760     case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
6761       return expand_builtin_atomic_always_lock_free (exp);
6762
6763     case BUILT_IN_ATOMIC_IS_LOCK_FREE:
6764       target = expand_builtin_atomic_is_lock_free (exp);
6765       if (target)
6766         return target;
6767       break;
6768
6769     case BUILT_IN_ATOMIC_THREAD_FENCE:
6770       expand_builtin_atomic_thread_fence (exp);
6771       return const0_rtx;
6772
6773     case BUILT_IN_ATOMIC_SIGNAL_FENCE:
6774       expand_builtin_atomic_signal_fence (exp);
6775       return const0_rtx;
6776
6777     case BUILT_IN_OBJECT_SIZE:
6778       return expand_builtin_object_size (exp);
6779
6780     case BUILT_IN_MEMCPY_CHK:
6781     case BUILT_IN_MEMPCPY_CHK:
6782     case BUILT_IN_MEMMOVE_CHK:
6783     case BUILT_IN_MEMSET_CHK:
6784       target = expand_builtin_memory_chk (exp, target, mode, fcode);
6785       if (target)
6786         return target;
6787       break;
6788
6789     case BUILT_IN_STRCPY_CHK:
6790     case BUILT_IN_STPCPY_CHK:
6791     case BUILT_IN_STRNCPY_CHK:
6792     case BUILT_IN_STPNCPY_CHK:
6793     case BUILT_IN_STRCAT_CHK:
6794     case BUILT_IN_STRNCAT_CHK:
6795     case BUILT_IN_SNPRINTF_CHK:
6796     case BUILT_IN_VSNPRINTF_CHK:
6797       maybe_emit_chk_warning (exp, fcode);
6798       break;
6799
6800     case BUILT_IN_SPRINTF_CHK:
6801     case BUILT_IN_VSPRINTF_CHK:
6802       maybe_emit_sprintf_chk_warning (exp, fcode);
6803       break;
6804
6805     case BUILT_IN_FREE:
6806       if (warn_free_nonheap_object)
6807         maybe_emit_free_warning (exp);
6808       break;
6809
6810     default:    /* just do library call, if unknown builtin */
6811       break;
6812     }
6813
6814   /* The switch statement above can drop through to cause the function
6815      to be called normally.  */
6816   return expand_call (exp, target, ignore);
6817 }
6818
6819 /* Determine whether a tree node represents a call to a built-in
6820    function.  If the tree T is a call to a built-in function with
6821    the right number of arguments of the appropriate types, return
6822    the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6823    Otherwise the return value is END_BUILTINS.  */
6824
6825 enum built_in_function
6826 builtin_mathfn_code (const_tree t)
6827 {
6828   const_tree fndecl, arg, parmlist;
6829   const_tree argtype, parmtype;
6830   const_call_expr_arg_iterator iter;
6831
6832   if (TREE_CODE (t) != CALL_EXPR
6833       || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6834     return END_BUILTINS;
6835
6836   fndecl = get_callee_fndecl (t);
6837   if (fndecl == NULL_TREE
6838       || TREE_CODE (fndecl) != FUNCTION_DECL
6839       || ! DECL_BUILT_IN (fndecl)
6840       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6841     return END_BUILTINS;
6842
6843   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6844   init_const_call_expr_arg_iterator (t, &iter);
6845   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6846     {
6847       /* If a function doesn't take a variable number of arguments,
6848          the last element in the list will have type `void'.  */
6849       parmtype = TREE_VALUE (parmlist);
6850       if (VOID_TYPE_P (parmtype))
6851         {
6852           if (more_const_call_expr_args_p (&iter))
6853             return END_BUILTINS;
6854           return DECL_FUNCTION_CODE (fndecl);
6855         }
6856
6857       if (! more_const_call_expr_args_p (&iter))
6858         return END_BUILTINS;
6859
6860       arg = next_const_call_expr_arg (&iter);
6861       argtype = TREE_TYPE (arg);
6862
6863       if (SCALAR_FLOAT_TYPE_P (parmtype))
6864         {
6865           if (! SCALAR_FLOAT_TYPE_P (argtype))
6866             return END_BUILTINS;
6867         }
6868       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6869         {
6870           if (! COMPLEX_FLOAT_TYPE_P (argtype))
6871             return END_BUILTINS;
6872         }
6873       else if (POINTER_TYPE_P (parmtype))
6874         {
6875           if (! POINTER_TYPE_P (argtype))
6876             return END_BUILTINS;
6877         }
6878       else if (INTEGRAL_TYPE_P (parmtype))
6879         {
6880           if (! INTEGRAL_TYPE_P (argtype))
6881             return END_BUILTINS;
6882         }
6883       else
6884         return END_BUILTINS;
6885     }
6886
6887   /* Variable-length argument list.  */
6888   return DECL_FUNCTION_CODE (fndecl);
6889 }
6890
6891 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6892    evaluate to a constant.  */
6893
6894 static tree
6895 fold_builtin_constant_p (tree arg)
6896 {
6897   /* We return 1 for a numeric type that's known to be a constant
6898      value at compile-time or for an aggregate type that's a
6899      literal constant.  */
6900   STRIP_NOPS (arg);
6901
6902   /* If we know this is a constant, emit the constant of one.  */
6903   if (CONSTANT_CLASS_P (arg)
6904       || (TREE_CODE (arg) == CONSTRUCTOR
6905           && TREE_CONSTANT (arg)))
6906     return integer_one_node;
6907   if (TREE_CODE (arg) == ADDR_EXPR)
6908     {
6909        tree op = TREE_OPERAND (arg, 0);
6910        if (TREE_CODE (op) == STRING_CST
6911            || (TREE_CODE (op) == ARRAY_REF
6912                && integer_zerop (TREE_OPERAND (op, 1))
6913                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6914          return integer_one_node;
6915     }
6916
6917   /* If this expression has side effects, show we don't know it to be a
6918      constant.  Likewise if it's a pointer or aggregate type since in
6919      those case we only want literals, since those are only optimized
6920      when generating RTL, not later.
6921      And finally, if we are compiling an initializer, not code, we
6922      need to return a definite result now; there's not going to be any
6923      more optimization done.  */
6924   if (TREE_SIDE_EFFECTS (arg)
6925       || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6926       || POINTER_TYPE_P (TREE_TYPE (arg))
6927       || cfun == 0
6928       || folding_initializer)
6929     return integer_zero_node;
6930
6931   return NULL_TREE;
6932 }
6933
6934 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6935    return it as a truthvalue.  */
6936
6937 static tree
6938 build_builtin_expect_predicate (location_t loc, tree pred, tree expected)
6939 {
6940   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6941
6942   fn = builtin_decl_explicit (BUILT_IN_EXPECT);
6943   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6944   ret_type = TREE_TYPE (TREE_TYPE (fn));
6945   pred_type = TREE_VALUE (arg_types);
6946   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6947
6948   pred = fold_convert_loc (loc, pred_type, pred);
6949   expected = fold_convert_loc (loc, expected_type, expected);
6950   call_expr = build_call_expr_loc (loc, fn, 2, pred, expected);
6951
6952   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6953                  build_int_cst (ret_type, 0));
6954 }
6955
6956 /* Fold a call to builtin_expect with arguments ARG0 and ARG1.  Return
6957    NULL_TREE if no simplification is possible.  */
6958
6959 static tree
6960 fold_builtin_expect (location_t loc, tree arg0, tree arg1)
6961 {
6962   tree inner, fndecl, inner_arg0;
6963   enum tree_code code;
6964
6965   /* Distribute the expected value over short-circuiting operators.
6966      See through the cast from truthvalue_type_node to long.  */
6967   inner_arg0 = arg0;
6968   while (TREE_CODE (inner_arg0) == NOP_EXPR
6969          && INTEGRAL_TYPE_P (TREE_TYPE (inner_arg0))
6970          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner_arg0, 0))))
6971     inner_arg0 = TREE_OPERAND (inner_arg0, 0);
6972
6973   /* If this is a builtin_expect within a builtin_expect keep the
6974      inner one.  See through a comparison against a constant.  It
6975      might have been added to create a thruthvalue.  */
6976   inner = inner_arg0;
6977
6978   if (COMPARISON_CLASS_P (inner)
6979       && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6980     inner = TREE_OPERAND (inner, 0);
6981
6982   if (TREE_CODE (inner) == CALL_EXPR
6983       && (fndecl = get_callee_fndecl (inner))
6984       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6985       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6986     return arg0;
6987
6988   inner = inner_arg0;
6989   code = TREE_CODE (inner);
6990   if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6991     {
6992       tree op0 = TREE_OPERAND (inner, 0);
6993       tree op1 = TREE_OPERAND (inner, 1);
6994
6995       op0 = build_builtin_expect_predicate (loc, op0, arg1);
6996       op1 = build_builtin_expect_predicate (loc, op1, arg1);
6997       inner = build2 (code, TREE_TYPE (inner), op0, op1);
6998
6999       return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
7000     }
7001
7002   /* If the argument isn't invariant then there's nothing else we can do.  */
7003   if (!TREE_CONSTANT (inner_arg0))
7004     return NULL_TREE;
7005
7006   /* If we expect that a comparison against the argument will fold to
7007      a constant return the constant.  In practice, this means a true
7008      constant or the address of a non-weak symbol.  */
7009   inner = inner_arg0;
7010   STRIP_NOPS (inner);
7011   if (TREE_CODE (inner) == ADDR_EXPR)
7012     {
7013       do
7014         {
7015           inner = TREE_OPERAND (inner, 0);
7016         }
7017       while (TREE_CODE (inner) == COMPONENT_REF
7018              || TREE_CODE (inner) == ARRAY_REF);
7019       if ((TREE_CODE (inner) == VAR_DECL
7020            || TREE_CODE (inner) == FUNCTION_DECL)
7021           && DECL_WEAK (inner))
7022         return NULL_TREE;
7023     }
7024
7025   /* Otherwise, ARG0 already has the proper type for the return value.  */
7026   return arg0;
7027 }
7028
7029 /* Fold a call to __builtin_classify_type with argument ARG.  */
7030
7031 static tree
7032 fold_builtin_classify_type (tree arg)
7033 {
7034   if (arg == 0)
7035     return build_int_cst (integer_type_node, no_type_class);
7036
7037   return build_int_cst (integer_type_node, type_to_class (TREE_TYPE (arg)));
7038 }
7039
7040 /* Fold a call to __builtin_strlen with argument ARG.  */
7041
7042 static tree
7043 fold_builtin_strlen (location_t loc, tree type, tree arg)
7044 {
7045   if (!validate_arg (arg, POINTER_TYPE))
7046     return NULL_TREE;
7047   else
7048     {
7049       tree len = c_strlen (arg, 0);
7050
7051       if (len)
7052         return fold_convert_loc (loc, type, len);
7053
7054       return NULL_TREE;
7055     }
7056 }
7057
7058 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
7059
7060 static tree
7061 fold_builtin_inf (location_t loc, tree type, int warn)
7062 {
7063   REAL_VALUE_TYPE real;
7064
7065   /* __builtin_inff is intended to be usable to define INFINITY on all
7066      targets.  If an infinity is not available, INFINITY expands "to a
7067      positive constant of type float that overflows at translation
7068      time", footnote "In this case, using INFINITY will violate the
7069      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
7070      Thus we pedwarn to ensure this constraint violation is
7071      diagnosed.  */
7072   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
7073     pedwarn (loc, 0, "target format does not support infinity");
7074
7075   real_inf (&real);
7076   return build_real (type, real);
7077 }
7078
7079 /* Fold a call to __builtin_nan or __builtin_nans with argument ARG.  */
7080
7081 static tree
7082 fold_builtin_nan (tree arg, tree type, int quiet)
7083 {
7084   REAL_VALUE_TYPE real;
7085   const char *str;
7086
7087   if (!validate_arg (arg, POINTER_TYPE))
7088     return NULL_TREE;
7089   str = c_getstr (arg);
7090   if (!str)
7091     return NULL_TREE;
7092
7093   if (!real_nan (&real, str, quiet, TYPE_MODE (type)))
7094     return NULL_TREE;
7095
7096   return build_real (type, real);
7097 }
7098
7099 /* Return true if the floating point expression T has an integer value.
7100    We also allow +Inf, -Inf and NaN to be considered integer values.  */
7101
7102 static bool
7103 integer_valued_real_p (tree t)
7104 {
7105   switch (TREE_CODE (t))
7106     {
7107     case FLOAT_EXPR:
7108       return true;
7109
7110     case ABS_EXPR:
7111     case SAVE_EXPR:
7112       return integer_valued_real_p (TREE_OPERAND (t, 0));
7113
7114     case COMPOUND_EXPR:
7115     case MODIFY_EXPR:
7116     case BIND_EXPR:
7117       return integer_valued_real_p (TREE_OPERAND (t, 1));
7118
7119     case PLUS_EXPR:
7120     case MINUS_EXPR:
7121     case MULT_EXPR:
7122     case MIN_EXPR:
7123     case MAX_EXPR:
7124       return integer_valued_real_p (TREE_OPERAND (t, 0))
7125              && integer_valued_real_p (TREE_OPERAND (t, 1));
7126
7127     case COND_EXPR:
7128       return integer_valued_real_p (TREE_OPERAND (t, 1))
7129              && integer_valued_real_p (TREE_OPERAND (t, 2));
7130
7131     case REAL_CST:
7132       return real_isinteger (TREE_REAL_CST_PTR (t), TYPE_MODE (TREE_TYPE (t)));
7133
7134     case NOP_EXPR:
7135       {
7136         tree type = TREE_TYPE (TREE_OPERAND (t, 0));
7137         if (TREE_CODE (type) == INTEGER_TYPE)
7138           return true;
7139         if (TREE_CODE (type) == REAL_TYPE)
7140           return integer_valued_real_p (TREE_OPERAND (t, 0));
7141         break;
7142       }
7143
7144     case CALL_EXPR:
7145       switch (builtin_mathfn_code (t))
7146         {
7147         CASE_FLT_FN (BUILT_IN_CEIL):
7148         CASE_FLT_FN (BUILT_IN_FLOOR):
7149         CASE_FLT_FN (BUILT_IN_NEARBYINT):
7150         CASE_FLT_FN (BUILT_IN_RINT):
7151         CASE_FLT_FN (BUILT_IN_ROUND):
7152         CASE_FLT_FN (BUILT_IN_TRUNC):
7153           return true;
7154
7155         CASE_FLT_FN (BUILT_IN_FMIN):
7156         CASE_FLT_FN (BUILT_IN_FMAX):
7157           return integer_valued_real_p (CALL_EXPR_ARG (t, 0))
7158             && integer_valued_real_p (CALL_EXPR_ARG (t, 1));
7159
7160         default:
7161           break;
7162         }
7163       break;
7164
7165     default:
7166       break;
7167     }
7168   return false;
7169 }
7170
7171 /* FNDECL is assumed to be a builtin where truncation can be propagated
7172    across (for instance floor((double)f) == (double)floorf (f).
7173    Do the transformation for a call with argument ARG.  */
7174
7175 static tree
7176 fold_trunc_transparent_mathfn (location_t loc, tree fndecl, tree arg)
7177 {
7178   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7179
7180   if (!validate_arg (arg, REAL_TYPE))
7181     return NULL_TREE;
7182
7183   /* Integer rounding functions are idempotent.  */
7184   if (fcode == builtin_mathfn_code (arg))
7185     return arg;
7186
7187   /* If argument is already integer valued, and we don't need to worry
7188      about setting errno, there's no need to perform rounding.  */
7189   if (! flag_errno_math && integer_valued_real_p (arg))
7190     return arg;
7191
7192   if (optimize)
7193     {
7194       tree arg0 = strip_float_extensions (arg);
7195       tree ftype = TREE_TYPE (TREE_TYPE (fndecl));
7196       tree newtype = TREE_TYPE (arg0);
7197       tree decl;
7198
7199       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7200           && (decl = mathfn_built_in (newtype, fcode)))
7201         return fold_convert_loc (loc, ftype,
7202                                  build_call_expr_loc (loc, decl, 1,
7203                                                   fold_convert_loc (loc,
7204                                                                     newtype,
7205                                                                     arg0)));
7206     }
7207   return NULL_TREE;
7208 }
7209
7210 /* FNDECL is assumed to be builtin which can narrow the FP type of
7211    the argument, for instance lround((double)f) -> lroundf (f).
7212    Do the transformation for a call with argument ARG.  */
7213
7214 static tree
7215 fold_fixed_mathfn (location_t loc, tree fndecl, tree arg)
7216 {
7217   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7218
7219   if (!validate_arg (arg, REAL_TYPE))
7220     return NULL_TREE;
7221
7222   /* If argument is already integer valued, and we don't need to worry
7223      about setting errno, there's no need to perform rounding.  */
7224   if (! flag_errno_math && integer_valued_real_p (arg))
7225     return fold_build1_loc (loc, FIX_TRUNC_EXPR,
7226                         TREE_TYPE (TREE_TYPE (fndecl)), arg);
7227
7228   if (optimize)
7229     {
7230       tree ftype = TREE_TYPE (arg);
7231       tree arg0 = strip_float_extensions (arg);
7232       tree newtype = TREE_TYPE (arg0);
7233       tree decl;
7234
7235       if (TYPE_PRECISION (newtype) < TYPE_PRECISION (ftype)
7236           && (decl = mathfn_built_in (newtype, fcode)))
7237         return build_call_expr_loc (loc, decl, 1,
7238                                 fold_convert_loc (loc, newtype, arg0));
7239     }
7240
7241   /* Canonicalize iround (x) to lround (x) on ILP32 targets where
7242      sizeof (int) == sizeof (long).  */
7243   if (TYPE_PRECISION (integer_type_node)
7244       == TYPE_PRECISION (long_integer_type_node))
7245     {
7246       tree newfn = NULL_TREE;
7247       switch (fcode)
7248         {
7249         CASE_FLT_FN (BUILT_IN_ICEIL):
7250           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
7251           break;
7252
7253         CASE_FLT_FN (BUILT_IN_IFLOOR):
7254           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
7255           break;
7256
7257         CASE_FLT_FN (BUILT_IN_IROUND):
7258           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
7259           break;
7260
7261         CASE_FLT_FN (BUILT_IN_IRINT):
7262           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7263           break;
7264
7265         default:
7266           break;
7267         }
7268
7269       if (newfn)
7270         {
7271           tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7272           return fold_convert_loc (loc,
7273                                    TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7274         }
7275     }
7276
7277   /* Canonicalize llround (x) to lround (x) on LP64 targets where
7278      sizeof (long long) == sizeof (long).  */
7279   if (TYPE_PRECISION (long_long_integer_type_node)
7280       == TYPE_PRECISION (long_integer_type_node))
7281     {
7282       tree newfn = NULL_TREE;
7283       switch (fcode)
7284         {
7285         CASE_FLT_FN (BUILT_IN_LLCEIL):
7286           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LCEIL);
7287           break;
7288
7289         CASE_FLT_FN (BUILT_IN_LLFLOOR):
7290           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LFLOOR);
7291           break;
7292
7293         CASE_FLT_FN (BUILT_IN_LLROUND):
7294           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LROUND);
7295           break;
7296
7297         CASE_FLT_FN (BUILT_IN_LLRINT):
7298           newfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_LRINT);
7299           break;
7300
7301         default:
7302           break;
7303         }
7304
7305       if (newfn)
7306         {
7307           tree newcall = build_call_expr_loc (loc, newfn, 1, arg);
7308           return fold_convert_loc (loc,
7309                                    TREE_TYPE (TREE_TYPE (fndecl)), newcall);
7310         }
7311     }
7312
7313   return NULL_TREE;
7314 }
7315
7316 /* Fold call to builtin cabs, cabsf or cabsl with argument ARG.  TYPE is the
7317    return type.  Return NULL_TREE if no simplification can be made.  */
7318
7319 static tree
7320 fold_builtin_cabs (location_t loc, tree arg, tree type, tree fndecl)
7321 {
7322   tree res;
7323
7324   if (!validate_arg (arg, COMPLEX_TYPE)
7325       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7326     return NULL_TREE;
7327
7328   /* Calculate the result when the argument is a constant.  */
7329   if (TREE_CODE (arg) == COMPLEX_CST
7330       && (res = do_mpfr_arg2 (TREE_REALPART (arg), TREE_IMAGPART (arg),
7331                               type, mpfr_hypot)))
7332     return res;
7333
7334   if (TREE_CODE (arg) == COMPLEX_EXPR)
7335     {
7336       tree real = TREE_OPERAND (arg, 0);
7337       tree imag = TREE_OPERAND (arg, 1);
7338
7339       /* If either part is zero, cabs is fabs of the other.  */
7340       if (real_zerop (real))
7341         return fold_build1_loc (loc, ABS_EXPR, type, imag);
7342       if (real_zerop (imag))
7343         return fold_build1_loc (loc, ABS_EXPR, type, real);
7344
7345       /* cabs(x+xi) -> fabs(x)*sqrt(2).  */
7346       if (flag_unsafe_math_optimizations
7347           && operand_equal_p (real, imag, OEP_PURE_SAME))
7348         {
7349           const REAL_VALUE_TYPE sqrt2_trunc
7350             = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
7351           STRIP_NOPS (real);
7352           return fold_build2_loc (loc, MULT_EXPR, type,
7353                               fold_build1_loc (loc, ABS_EXPR, type, real),
7354                               build_real (type, sqrt2_trunc));
7355         }
7356     }
7357
7358   /* Optimize cabs(-z) and cabs(conj(z)) as cabs(z).  */
7359   if (TREE_CODE (arg) == NEGATE_EXPR
7360       || TREE_CODE (arg) == CONJ_EXPR)
7361     return build_call_expr_loc (loc, fndecl, 1, TREE_OPERAND (arg, 0));
7362
7363   /* Don't do this when optimizing for size.  */
7364   if (flag_unsafe_math_optimizations
7365       && optimize && optimize_function_for_speed_p (cfun))
7366     {
7367       tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
7368
7369       if (sqrtfn != NULL_TREE)
7370         {
7371           tree rpart, ipart, result;
7372
7373           arg = builtin_save_expr (arg);
7374
7375           rpart = fold_build1_loc (loc, REALPART_EXPR, type, arg);
7376           ipart = fold_build1_loc (loc, IMAGPART_EXPR, type, arg);
7377
7378           rpart = builtin_save_expr (rpart);
7379           ipart = builtin_save_expr (ipart);
7380
7381           result = fold_build2_loc (loc, PLUS_EXPR, type,
7382                                 fold_build2_loc (loc, MULT_EXPR, type,
7383                                              rpart, rpart),
7384                                 fold_build2_loc (loc, MULT_EXPR, type,
7385                                              ipart, ipart));
7386
7387           return build_call_expr_loc (loc, sqrtfn, 1, result);
7388         }
7389     }
7390
7391   return NULL_TREE;
7392 }
7393
7394 /* Build a complex (inf +- 0i) for the result of cproj.  TYPE is the
7395    complex tree type of the result.  If NEG is true, the imaginary
7396    zero is negative.  */
7397
7398 static tree
7399 build_complex_cproj (tree type, bool neg)
7400 {
7401   REAL_VALUE_TYPE rinf, rzero = dconst0;
7402
7403   real_inf (&rinf);
7404   rzero.sign = neg;
7405   return build_complex (type, build_real (TREE_TYPE (type), rinf),
7406                         build_real (TREE_TYPE (type), rzero));
7407 }
7408
7409 /* Fold call to builtin cproj, cprojf or cprojl with argument ARG.  TYPE is the
7410    return type.  Return NULL_TREE if no simplification can be made.  */
7411
7412 static tree
7413 fold_builtin_cproj (location_t loc, tree arg, tree type)
7414 {
7415   if (!validate_arg (arg, COMPLEX_TYPE)
7416       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) != REAL_TYPE)
7417     return NULL_TREE;
7418
7419   /* If there are no infinities, return arg.  */
7420   if (! HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (type))))
7421     return non_lvalue_loc (loc, arg);
7422
7423   /* Calculate the result when the argument is a constant.  */
7424   if (TREE_CODE (arg) == COMPLEX_CST)
7425     {
7426       const REAL_VALUE_TYPE *real = TREE_REAL_CST_PTR (TREE_REALPART (arg));
7427       const REAL_VALUE_TYPE *imag = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
7428
7429       if (real_isinf (real) || real_isinf (imag))
7430         return build_complex_cproj (type, imag->sign);
7431       else
7432         return arg;
7433     }
7434   else if (TREE_CODE (arg) == COMPLEX_EXPR)
7435     {
7436       tree real = TREE_OPERAND (arg, 0);
7437       tree imag = TREE_OPERAND (arg, 1);
7438
7439       STRIP_NOPS (real);
7440       STRIP_NOPS (imag);
7441
7442       /* If the real part is inf and the imag part is known to be
7443          nonnegative, return (inf + 0i).  Remember side-effects are
7444          possible in the imag part.  */
7445       if (TREE_CODE (real) == REAL_CST
7446           && real_isinf (TREE_REAL_CST_PTR (real))
7447           && tree_expr_nonnegative_p (imag))
7448         return omit_one_operand_loc (loc, type,
7449                                      build_complex_cproj (type, false),
7450                                      arg);
7451
7452       /* If the imag part is inf, return (inf+I*copysign(0,imag)).
7453          Remember side-effects are possible in the real part.  */
7454       if (TREE_CODE (imag) == REAL_CST
7455           && real_isinf (TREE_REAL_CST_PTR (imag)))
7456         return
7457           omit_one_operand_loc (loc, type,
7458                                 build_complex_cproj (type, TREE_REAL_CST_PTR
7459                                                      (imag)->sign), arg);
7460     }
7461
7462   return NULL_TREE;
7463 }
7464
7465 /* Fold a builtin function call to sqrt, sqrtf, or sqrtl with argument ARG.
7466    Return NULL_TREE if no simplification can be made.  */
7467
7468 static tree
7469 fold_builtin_sqrt (location_t loc, tree arg, tree type)
7470 {
7471
7472   enum built_in_function fcode;
7473   tree res;
7474
7475   if (!validate_arg (arg, REAL_TYPE))
7476     return NULL_TREE;
7477
7478   /* Calculate the result when the argument is a constant.  */
7479   if ((res = do_mpfr_arg1 (arg, type, mpfr_sqrt, &dconst0, NULL, true)))
7480     return res;
7481
7482   /* Optimize sqrt(expN(x)) = expN(x*0.5).  */
7483   fcode = builtin_mathfn_code (arg);
7484   if (flag_unsafe_math_optimizations && BUILTIN_EXPONENT_P (fcode))
7485     {
7486       tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7487       arg = fold_build2_loc (loc, MULT_EXPR, type,
7488                          CALL_EXPR_ARG (arg, 0),
7489                          build_real (type, dconsthalf));
7490       return build_call_expr_loc (loc, expfn, 1, arg);
7491     }
7492
7493   /* Optimize sqrt(Nroot(x)) -> pow(x,1/(2*N)).  */
7494   if (flag_unsafe_math_optimizations && BUILTIN_ROOT_P (fcode))
7495     {
7496       tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7497
7498       if (powfn)
7499         {
7500           tree arg0 = CALL_EXPR_ARG (arg, 0);
7501           tree tree_root;
7502           /* The inner root was either sqrt or cbrt.  */
7503           /* This was a conditional expression but it triggered a bug
7504              in Sun C 5.5.  */
7505           REAL_VALUE_TYPE dconstroot;
7506           if (BUILTIN_SQRT_P (fcode))
7507             dconstroot = dconsthalf;
7508           else
7509             dconstroot = dconst_third ();
7510
7511           /* Adjust for the outer root.  */
7512           SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7513           dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7514           tree_root = build_real (type, dconstroot);
7515           return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7516         }
7517     }
7518
7519   /* Optimize sqrt(pow(x,y)) = pow(|x|,y*0.5).  */
7520   if (flag_unsafe_math_optimizations
7521       && (fcode == BUILT_IN_POW
7522           || fcode == BUILT_IN_POWF
7523           || fcode == BUILT_IN_POWL))
7524     {
7525       tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7526       tree arg0 = CALL_EXPR_ARG (arg, 0);
7527       tree arg1 = CALL_EXPR_ARG (arg, 1);
7528       tree narg1;
7529       if (!tree_expr_nonnegative_p (arg0))
7530         arg0 = build1 (ABS_EXPR, type, arg0);
7531       narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
7532                            build_real (type, dconsthalf));
7533       return build_call_expr_loc (loc, powfn, 2, arg0, narg1);
7534     }
7535
7536   return NULL_TREE;
7537 }
7538
7539 /* Fold a builtin function call to cbrt, cbrtf, or cbrtl with argument ARG.
7540    Return NULL_TREE if no simplification can be made.  */
7541
7542 static tree
7543 fold_builtin_cbrt (location_t loc, tree arg, tree type)
7544 {
7545   const enum built_in_function fcode = builtin_mathfn_code (arg);
7546   tree res;
7547
7548   if (!validate_arg (arg, REAL_TYPE))
7549     return NULL_TREE;
7550
7551   /* Calculate the result when the argument is a constant.  */
7552   if ((res = do_mpfr_arg1 (arg, type, mpfr_cbrt, NULL, NULL, 0)))
7553     return res;
7554
7555   if (flag_unsafe_math_optimizations)
7556     {
7557       /* Optimize cbrt(expN(x)) -> expN(x/3).  */
7558       if (BUILTIN_EXPONENT_P (fcode))
7559         {
7560           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7561           const REAL_VALUE_TYPE third_trunc =
7562             real_value_truncate (TYPE_MODE (type), dconst_third ());
7563           arg = fold_build2_loc (loc, MULT_EXPR, type,
7564                              CALL_EXPR_ARG (arg, 0),
7565                              build_real (type, third_trunc));
7566           return build_call_expr_loc (loc, expfn, 1, arg);
7567         }
7568
7569       /* Optimize cbrt(sqrt(x)) -> pow(x,1/6).  */
7570       if (BUILTIN_SQRT_P (fcode))
7571         {
7572           tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7573
7574           if (powfn)
7575             {
7576               tree arg0 = CALL_EXPR_ARG (arg, 0);
7577               tree tree_root;
7578               REAL_VALUE_TYPE dconstroot = dconst_third ();
7579
7580               SET_REAL_EXP (&dconstroot, REAL_EXP (&dconstroot) - 1);
7581               dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7582               tree_root = build_real (type, dconstroot);
7583               return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7584             }
7585         }
7586
7587       /* Optimize cbrt(cbrt(x)) -> pow(x,1/9) iff x is nonnegative.  */
7588       if (BUILTIN_CBRT_P (fcode))
7589         {
7590           tree arg0 = CALL_EXPR_ARG (arg, 0);
7591           if (tree_expr_nonnegative_p (arg0))
7592             {
7593               tree powfn = mathfn_built_in (type, BUILT_IN_POW);
7594
7595               if (powfn)
7596                 {
7597                   tree tree_root;
7598                   REAL_VALUE_TYPE dconstroot;
7599
7600                   real_arithmetic (&dconstroot, MULT_EXPR,
7601                                    dconst_third_ptr (), dconst_third_ptr ());
7602                   dconstroot = real_value_truncate (TYPE_MODE (type), dconstroot);
7603                   tree_root = build_real (type, dconstroot);
7604                   return build_call_expr_loc (loc, powfn, 2, arg0, tree_root);
7605                 }
7606             }
7607         }
7608
7609       /* Optimize cbrt(pow(x,y)) -> pow(x,y/3) iff x is nonnegative.  */
7610       if (fcode == BUILT_IN_POW
7611           || fcode == BUILT_IN_POWF
7612           || fcode == BUILT_IN_POWL)
7613         {
7614           tree arg00 = CALL_EXPR_ARG (arg, 0);
7615           tree arg01 = CALL_EXPR_ARG (arg, 1);
7616           if (tree_expr_nonnegative_p (arg00))
7617             {
7618               tree powfn = TREE_OPERAND (CALL_EXPR_FN (arg), 0);
7619               const REAL_VALUE_TYPE dconstroot
7620                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
7621               tree narg01 = fold_build2_loc (loc, MULT_EXPR, type, arg01,
7622                                          build_real (type, dconstroot));
7623               return build_call_expr_loc (loc, powfn, 2, arg00, narg01);
7624             }
7625         }
7626     }
7627   return NULL_TREE;
7628 }
7629
7630 /* Fold function call to builtin cos, cosf, or cosl with argument ARG.
7631    TYPE is the type of the return value.  Return NULL_TREE if no
7632    simplification can be made.  */
7633
7634 static tree
7635 fold_builtin_cos (location_t loc,
7636                   tree arg, tree type, tree fndecl)
7637 {
7638   tree res, narg;
7639
7640   if (!validate_arg (arg, REAL_TYPE))
7641     return NULL_TREE;
7642
7643   /* Calculate the result when the argument is a constant.  */
7644   if ((res = do_mpfr_arg1 (arg, type, mpfr_cos, NULL, NULL, 0)))
7645     return res;
7646
7647   /* Optimize cos(-x) into cos (x).  */
7648   if ((narg = fold_strip_sign_ops (arg)))
7649     return build_call_expr_loc (loc, fndecl, 1, narg);
7650
7651   return NULL_TREE;
7652 }
7653
7654 /* Fold function call to builtin cosh, coshf, or coshl with argument ARG.
7655    Return NULL_TREE if no simplification can be made.  */
7656
7657 static tree
7658 fold_builtin_cosh (location_t loc, tree arg, tree type, tree fndecl)
7659 {
7660   if (validate_arg (arg, REAL_TYPE))
7661     {
7662       tree res, narg;
7663
7664       /* Calculate the result when the argument is a constant.  */
7665       if ((res = do_mpfr_arg1 (arg, type, mpfr_cosh, NULL, NULL, 0)))
7666         return res;
7667
7668       /* Optimize cosh(-x) into cosh (x).  */
7669       if ((narg = fold_strip_sign_ops (arg)))
7670         return build_call_expr_loc (loc, fndecl, 1, narg);
7671     }
7672
7673   return NULL_TREE;
7674 }
7675
7676 /* Fold function call to builtin ccos (or ccosh if HYPER is TRUE) with
7677    argument ARG.  TYPE is the type of the return value.  Return
7678    NULL_TREE if no simplification can be made.  */
7679
7680 static tree
7681 fold_builtin_ccos (location_t loc, tree arg, tree type, tree fndecl,
7682                    bool hyper)
7683 {
7684   if (validate_arg (arg, COMPLEX_TYPE)
7685       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7686     {
7687       tree tmp;
7688
7689       /* Calculate the result when the argument is a constant.  */
7690       if ((tmp = do_mpc_arg1 (arg, type, (hyper ? mpc_cosh : mpc_cos))))
7691         return tmp;
7692
7693       /* Optimize fn(-x) into fn(x).  */
7694       if ((tmp = fold_strip_sign_ops (arg)))
7695         return build_call_expr_loc (loc, fndecl, 1, tmp);
7696     }
7697
7698   return NULL_TREE;
7699 }
7700
7701 /* Fold function call to builtin tan, tanf, or tanl with argument ARG.
7702    Return NULL_TREE if no simplification can be made.  */
7703
7704 static tree
7705 fold_builtin_tan (tree arg, tree type)
7706 {
7707   enum built_in_function fcode;
7708   tree res;
7709
7710   if (!validate_arg (arg, REAL_TYPE))
7711     return NULL_TREE;
7712
7713   /* Calculate the result when the argument is a constant.  */
7714   if ((res = do_mpfr_arg1 (arg, type, mpfr_tan, NULL, NULL, 0)))
7715     return res;
7716
7717   /* Optimize tan(atan(x)) = x.  */
7718   fcode = builtin_mathfn_code (arg);
7719   if (flag_unsafe_math_optimizations
7720       && (fcode == BUILT_IN_ATAN
7721           || fcode == BUILT_IN_ATANF
7722           || fcode == BUILT_IN_ATANL))
7723     return CALL_EXPR_ARG (arg, 0);
7724
7725   return NULL_TREE;
7726 }
7727
7728 /* Fold function call to builtin sincos, sincosf, or sincosl.  Return
7729    NULL_TREE if no simplification can be made.  */
7730
7731 static tree
7732 fold_builtin_sincos (location_t loc,
7733                      tree arg0, tree arg1, tree arg2)
7734 {
7735   tree type;
7736   tree res, fn, call;
7737
7738   if (!validate_arg (arg0, REAL_TYPE)
7739       || !validate_arg (arg1, POINTER_TYPE)
7740       || !validate_arg (arg2, POINTER_TYPE))
7741     return NULL_TREE;
7742
7743   type = TREE_TYPE (arg0);
7744
7745   /* Calculate the result when the argument is a constant.  */
7746   if ((res = do_mpfr_sincos (arg0, arg1, arg2)))
7747     return res;
7748
7749   /* Canonicalize sincos to cexpi.  */
7750   if (!TARGET_C99_FUNCTIONS)
7751     return NULL_TREE;
7752   fn = mathfn_built_in (type, BUILT_IN_CEXPI);
7753   if (!fn)
7754     return NULL_TREE;
7755
7756   call = build_call_expr_loc (loc, fn, 1, arg0);
7757   call = builtin_save_expr (call);
7758
7759   return build2 (COMPOUND_EXPR, void_type_node,
7760                  build2 (MODIFY_EXPR, void_type_node,
7761                          build_fold_indirect_ref_loc (loc, arg1),
7762                          build1 (IMAGPART_EXPR, type, call)),
7763                  build2 (MODIFY_EXPR, void_type_node,
7764                          build_fold_indirect_ref_loc (loc, arg2),
7765                          build1 (REALPART_EXPR, type, call)));
7766 }
7767
7768 /* Fold function call to builtin cexp, cexpf, or cexpl.  Return
7769    NULL_TREE if no simplification can be made.  */
7770
7771 static tree
7772 fold_builtin_cexp (location_t loc, tree arg0, tree type)
7773 {
7774   tree rtype;
7775   tree realp, imagp, ifn;
7776   tree res;
7777
7778   if (!validate_arg (arg0, COMPLEX_TYPE)
7779       || TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) != REAL_TYPE)
7780     return NULL_TREE;
7781
7782   /* Calculate the result when the argument is a constant.  */
7783   if ((res = do_mpc_arg1 (arg0, type, mpc_exp)))
7784     return res;
7785
7786   rtype = TREE_TYPE (TREE_TYPE (arg0));
7787
7788   /* In case we can figure out the real part of arg0 and it is constant zero
7789      fold to cexpi.  */
7790   if (!TARGET_C99_FUNCTIONS)
7791     return NULL_TREE;
7792   ifn = mathfn_built_in (rtype, BUILT_IN_CEXPI);
7793   if (!ifn)
7794     return NULL_TREE;
7795
7796   if ((realp = fold_unary_loc (loc, REALPART_EXPR, rtype, arg0))
7797       && real_zerop (realp))
7798     {
7799       tree narg = fold_build1_loc (loc, IMAGPART_EXPR, rtype, arg0);
7800       return build_call_expr_loc (loc, ifn, 1, narg);
7801     }
7802
7803   /* In case we can easily decompose real and imaginary parts split cexp
7804      to exp (r) * cexpi (i).  */
7805   if (flag_unsafe_math_optimizations
7806       && realp)
7807     {
7808       tree rfn, rcall, icall;
7809
7810       rfn = mathfn_built_in (rtype, BUILT_IN_EXP);
7811       if (!rfn)
7812         return NULL_TREE;
7813
7814       imagp = fold_unary_loc (loc, IMAGPART_EXPR, rtype, arg0);
7815       if (!imagp)
7816         return NULL_TREE;
7817
7818       icall = build_call_expr_loc (loc, ifn, 1, imagp);
7819       icall = builtin_save_expr (icall);
7820       rcall = build_call_expr_loc (loc, rfn, 1, realp);
7821       rcall = builtin_save_expr (rcall);
7822       return fold_build2_loc (loc, COMPLEX_EXPR, type,
7823                           fold_build2_loc (loc, MULT_EXPR, rtype,
7824                                        rcall,
7825                                        fold_build1_loc (loc, REALPART_EXPR,
7826                                                     rtype, icall)),
7827                           fold_build2_loc (loc, MULT_EXPR, rtype,
7828                                        rcall,
7829                                        fold_build1_loc (loc, IMAGPART_EXPR,
7830                                                     rtype, icall)));
7831     }
7832
7833   return NULL_TREE;
7834 }
7835
7836 /* Fold function call to builtin trunc, truncf or truncl with argument ARG.
7837    Return NULL_TREE if no simplification can be made.  */
7838
7839 static tree
7840 fold_builtin_trunc (location_t loc, tree fndecl, tree arg)
7841 {
7842   if (!validate_arg (arg, REAL_TYPE))
7843     return NULL_TREE;
7844
7845   /* Optimize trunc of constant value.  */
7846   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7847     {
7848       REAL_VALUE_TYPE r, x;
7849       tree type = TREE_TYPE (TREE_TYPE (fndecl));
7850
7851       x = TREE_REAL_CST (arg);
7852       real_trunc (&r, TYPE_MODE (type), &x);
7853       return build_real (type, r);
7854     }
7855
7856   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7857 }
7858
7859 /* Fold function call to builtin floor, floorf or floorl with argument ARG.
7860    Return NULL_TREE if no simplification can be made.  */
7861
7862 static tree
7863 fold_builtin_floor (location_t loc, tree fndecl, tree arg)
7864 {
7865   if (!validate_arg (arg, REAL_TYPE))
7866     return NULL_TREE;
7867
7868   /* Optimize floor of constant value.  */
7869   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7870     {
7871       REAL_VALUE_TYPE x;
7872
7873       x = TREE_REAL_CST (arg);
7874       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7875         {
7876           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7877           REAL_VALUE_TYPE r;
7878
7879           real_floor (&r, TYPE_MODE (type), &x);
7880           return build_real (type, r);
7881         }
7882     }
7883
7884   /* Fold floor (x) where x is nonnegative to trunc (x).  */
7885   if (tree_expr_nonnegative_p (arg))
7886     {
7887       tree truncfn = mathfn_built_in (TREE_TYPE (arg), BUILT_IN_TRUNC);
7888       if (truncfn)
7889         return build_call_expr_loc (loc, truncfn, 1, arg);
7890     }
7891
7892   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7893 }
7894
7895 /* Fold function call to builtin ceil, ceilf or ceill with argument ARG.
7896    Return NULL_TREE if no simplification can be made.  */
7897
7898 static tree
7899 fold_builtin_ceil (location_t loc, tree fndecl, tree arg)
7900 {
7901   if (!validate_arg (arg, REAL_TYPE))
7902     return NULL_TREE;
7903
7904   /* Optimize ceil of constant value.  */
7905   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7906     {
7907       REAL_VALUE_TYPE x;
7908
7909       x = TREE_REAL_CST (arg);
7910       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7911         {
7912           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7913           REAL_VALUE_TYPE r;
7914
7915           real_ceil (&r, TYPE_MODE (type), &x);
7916           return build_real (type, r);
7917         }
7918     }
7919
7920   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7921 }
7922
7923 /* Fold function call to builtin round, roundf or roundl with argument ARG.
7924    Return NULL_TREE if no simplification can be made.  */
7925
7926 static tree
7927 fold_builtin_round (location_t loc, tree fndecl, tree arg)
7928 {
7929   if (!validate_arg (arg, REAL_TYPE))
7930     return NULL_TREE;
7931
7932   /* Optimize round of constant value.  */
7933   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7934     {
7935       REAL_VALUE_TYPE x;
7936
7937       x = TREE_REAL_CST (arg);
7938       if (! REAL_VALUE_ISNAN (x) || ! flag_errno_math)
7939         {
7940           tree type = TREE_TYPE (TREE_TYPE (fndecl));
7941           REAL_VALUE_TYPE r;
7942
7943           real_round (&r, TYPE_MODE (type), &x);
7944           return build_real (type, r);
7945         }
7946     }
7947
7948   return fold_trunc_transparent_mathfn (loc, fndecl, arg);
7949 }
7950
7951 /* Fold function call to builtin lround, lroundf or lroundl (or the
7952    corresponding long long versions) and other rounding functions.  ARG
7953    is the argument to the call.  Return NULL_TREE if no simplification
7954    can be made.  */
7955
7956 static tree
7957 fold_builtin_int_roundingfn (location_t loc, tree fndecl, tree arg)
7958 {
7959   if (!validate_arg (arg, REAL_TYPE))
7960     return NULL_TREE;
7961
7962   /* Optimize lround of constant value.  */
7963   if (TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
7964     {
7965       const REAL_VALUE_TYPE x = TREE_REAL_CST (arg);
7966
7967       if (real_isfinite (&x))
7968         {
7969           tree itype = TREE_TYPE (TREE_TYPE (fndecl));
7970           tree ftype = TREE_TYPE (arg);
7971           double_int val;
7972           REAL_VALUE_TYPE r;
7973
7974           switch (DECL_FUNCTION_CODE (fndecl))
7975             {
7976             CASE_FLT_FN (BUILT_IN_IFLOOR):
7977             CASE_FLT_FN (BUILT_IN_LFLOOR):
7978             CASE_FLT_FN (BUILT_IN_LLFLOOR):
7979               real_floor (&r, TYPE_MODE (ftype), &x);
7980               break;
7981
7982             CASE_FLT_FN (BUILT_IN_ICEIL):
7983             CASE_FLT_FN (BUILT_IN_LCEIL):
7984             CASE_FLT_FN (BUILT_IN_LLCEIL):
7985               real_ceil (&r, TYPE_MODE (ftype), &x);
7986               break;
7987
7988             CASE_FLT_FN (BUILT_IN_IROUND):
7989             CASE_FLT_FN (BUILT_IN_LROUND):
7990             CASE_FLT_FN (BUILT_IN_LLROUND):
7991               real_round (&r, TYPE_MODE (ftype), &x);
7992               break;
7993
7994             default:
7995               gcc_unreachable ();
7996             }
7997
7998           real_to_integer2 ((HOST_WIDE_INT *)&val.low, &val.high, &r);
7999           if (double_int_fits_to_tree_p (itype, val))
8000             return double_int_to_tree (itype, val);
8001         }
8002     }
8003
8004   switch (DECL_FUNCTION_CODE (fndecl))
8005     {
8006     CASE_FLT_FN (BUILT_IN_LFLOOR):
8007     CASE_FLT_FN (BUILT_IN_LLFLOOR):
8008       /* Fold lfloor (x) where x is nonnegative to FIX_TRUNC (x).  */
8009       if (tree_expr_nonnegative_p (arg))
8010         return fold_build1_loc (loc, FIX_TRUNC_EXPR,
8011                             TREE_TYPE (TREE_TYPE (fndecl)), arg);
8012       break;
8013     default:;
8014     }
8015
8016   return fold_fixed_mathfn (loc, fndecl, arg);
8017 }
8018
8019 /* Fold function call to builtin ffs, clz, ctz, popcount and parity
8020    and their long and long long variants (i.e. ffsl and ffsll).  ARG is
8021    the argument to the call.  Return NULL_TREE if no simplification can
8022    be made.  */
8023
8024 static tree
8025 fold_builtin_bitop (tree fndecl, tree arg)
8026 {
8027   if (!validate_arg (arg, INTEGER_TYPE))
8028     return NULL_TREE;
8029
8030   /* Optimize for constant argument.  */
8031   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
8032     {
8033       HOST_WIDE_INT hi, width, result;
8034       unsigned HOST_WIDE_INT lo;
8035       tree type;
8036
8037       type = TREE_TYPE (arg);
8038       width = TYPE_PRECISION (type);
8039       lo = TREE_INT_CST_LOW (arg);
8040
8041       /* Clear all the bits that are beyond the type's precision.  */
8042       if (width > HOST_BITS_PER_WIDE_INT)
8043         {
8044           hi = TREE_INT_CST_HIGH (arg);
8045           if (width < HOST_BITS_PER_DOUBLE_INT)
8046             hi &= ~((unsigned HOST_WIDE_INT) (-1)
8047                     << (width - HOST_BITS_PER_WIDE_INT));
8048         }
8049       else
8050         {
8051           hi = 0;
8052           if (width < HOST_BITS_PER_WIDE_INT)
8053             lo &= ~((unsigned HOST_WIDE_INT) (-1) << width);
8054         }
8055
8056       switch (DECL_FUNCTION_CODE (fndecl))
8057         {
8058         CASE_INT_FN (BUILT_IN_FFS):
8059           if (lo != 0)
8060             result = ffs_hwi (lo);
8061           else if (hi != 0)
8062             result = HOST_BITS_PER_WIDE_INT + ffs_hwi (hi);
8063           else
8064             result = 0;
8065           break;
8066
8067         CASE_INT_FN (BUILT_IN_CLZ):
8068           if (hi != 0)
8069             result = width - floor_log2 (hi) - 1 - HOST_BITS_PER_WIDE_INT;
8070           else if (lo != 0)
8071             result = width - floor_log2 (lo) - 1;
8072           else if (! CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
8073             result = width;
8074           break;
8075
8076         CASE_INT_FN (BUILT_IN_CTZ):
8077           if (lo != 0)
8078             result = ctz_hwi (lo);
8079           else if (hi != 0)
8080             result = HOST_BITS_PER_WIDE_INT + ctz_hwi (hi);
8081           else if (! CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (type), result))
8082             result = width;
8083           break;
8084
8085         CASE_INT_FN (BUILT_IN_CLRSB):
8086           if (width > HOST_BITS_PER_WIDE_INT
8087               && (hi & ((unsigned HOST_WIDE_INT) 1
8088                         << (width - HOST_BITS_PER_WIDE_INT - 1))) != 0)
8089             {
8090               hi = ~hi & ~((unsigned HOST_WIDE_INT) (-1)
8091                            << (width - HOST_BITS_PER_WIDE_INT - 1));
8092               lo = ~lo;
8093             }
8094           else if (width <= HOST_BITS_PER_WIDE_INT
8095                    && (lo & ((unsigned HOST_WIDE_INT) 1 << (width - 1))) != 0)
8096             lo = ~lo & ~((unsigned HOST_WIDE_INT) (-1) << (width - 1));
8097           if (hi != 0)
8098             result = width - floor_log2 (hi) - 2 - HOST_BITS_PER_WIDE_INT;
8099           else if (lo != 0)
8100             result = width - floor_log2 (lo) - 2;
8101           else
8102             result = width - 1;
8103           break;
8104
8105         CASE_INT_FN (BUILT_IN_POPCOUNT):
8106           result = 0;
8107           while (lo)
8108             result++, lo &= lo - 1;
8109           while (hi)
8110             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
8111           break;
8112
8113         CASE_INT_FN (BUILT_IN_PARITY):
8114           result = 0;
8115           while (lo)
8116             result++, lo &= lo - 1;
8117           while (hi)
8118             result++, hi &= (unsigned HOST_WIDE_INT) hi - 1;
8119           result &= 1;
8120           break;
8121
8122         default:
8123           gcc_unreachable ();
8124         }
8125
8126       return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), result);
8127     }
8128
8129   return NULL_TREE;
8130 }
8131
8132 /* Fold function call to builtin_bswap and the short, long and long long
8133    variants.  Return NULL_TREE if no simplification can be made.  */
8134 static tree
8135 fold_builtin_bswap (tree fndecl, tree arg)
8136 {
8137   if (! validate_arg (arg, INTEGER_TYPE))
8138     return NULL_TREE;
8139
8140   /* Optimize constant value.  */
8141   if (TREE_CODE (arg) == INTEGER_CST && !TREE_OVERFLOW (arg))
8142     {
8143       HOST_WIDE_INT hi, width, r_hi = 0;
8144       unsigned HOST_WIDE_INT lo, r_lo = 0;
8145       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8146
8147       width = TYPE_PRECISION (type);
8148       lo = TREE_INT_CST_LOW (arg);
8149       hi = TREE_INT_CST_HIGH (arg);
8150
8151       switch (DECL_FUNCTION_CODE (fndecl))
8152         {
8153           case BUILT_IN_BSWAP16:
8154           case BUILT_IN_BSWAP32:
8155           case BUILT_IN_BSWAP64:
8156             {
8157               int s;
8158
8159               for (s = 0; s < width; s += 8)
8160                 {
8161                   int d = width - s - 8;
8162                   unsigned HOST_WIDE_INT byte;
8163
8164                   if (s < HOST_BITS_PER_WIDE_INT)
8165                     byte = (lo >> s) & 0xff;
8166                   else
8167                     byte = (hi >> (s - HOST_BITS_PER_WIDE_INT)) & 0xff;
8168
8169                   if (d < HOST_BITS_PER_WIDE_INT)
8170                     r_lo |= byte << d;
8171                   else
8172                     r_hi |= byte << (d - HOST_BITS_PER_WIDE_INT);
8173                 }
8174             }
8175
8176             break;
8177
8178         default:
8179           gcc_unreachable ();
8180         }
8181
8182       if (width < HOST_BITS_PER_WIDE_INT)
8183         return build_int_cst (type, r_lo);
8184       else
8185         return build_int_cst_wide (type, r_lo, r_hi);
8186     }
8187
8188   return NULL_TREE;
8189 }
8190
8191 /* A subroutine of fold_builtin to fold the various logarithmic
8192    functions.  Return NULL_TREE if no simplification can me made.
8193    FUNC is the corresponding MPFR logarithm function.  */
8194
8195 static tree
8196 fold_builtin_logarithm (location_t loc, tree fndecl, tree arg,
8197                         int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8198 {
8199   if (validate_arg (arg, REAL_TYPE))
8200     {
8201       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8202       tree res;
8203       const enum built_in_function fcode = builtin_mathfn_code (arg);
8204
8205       /* Calculate the result when the argument is a constant.  */
8206       if ((res = do_mpfr_arg1 (arg, type, func, &dconst0, NULL, false)))
8207         return res;
8208
8209       /* Special case, optimize logN(expN(x)) = x.  */
8210       if (flag_unsafe_math_optimizations
8211           && ((func == mpfr_log
8212                && (fcode == BUILT_IN_EXP
8213                    || fcode == BUILT_IN_EXPF
8214                    || fcode == BUILT_IN_EXPL))
8215               || (func == mpfr_log2
8216                   && (fcode == BUILT_IN_EXP2
8217                       || fcode == BUILT_IN_EXP2F
8218                       || fcode == BUILT_IN_EXP2L))
8219               || (func == mpfr_log10 && (BUILTIN_EXP10_P (fcode)))))
8220         return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8221
8222       /* Optimize logN(func()) for various exponential functions.  We
8223          want to determine the value "x" and the power "exponent" in
8224          order to transform logN(x**exponent) into exponent*logN(x).  */
8225       if (flag_unsafe_math_optimizations)
8226         {
8227           tree exponent = 0, x = 0;
8228
8229           switch (fcode)
8230           {
8231           CASE_FLT_FN (BUILT_IN_EXP):
8232             /* Prepare to do logN(exp(exponent) -> exponent*logN(e).  */
8233             x = build_real (type, real_value_truncate (TYPE_MODE (type),
8234                                                        dconst_e ()));
8235             exponent = CALL_EXPR_ARG (arg, 0);
8236             break;
8237           CASE_FLT_FN (BUILT_IN_EXP2):
8238             /* Prepare to do logN(exp2(exponent) -> exponent*logN(2).  */
8239             x = build_real (type, dconst2);
8240             exponent = CALL_EXPR_ARG (arg, 0);
8241             break;
8242           CASE_FLT_FN (BUILT_IN_EXP10):
8243           CASE_FLT_FN (BUILT_IN_POW10):
8244             /* Prepare to do logN(exp10(exponent) -> exponent*logN(10).  */
8245             {
8246               REAL_VALUE_TYPE dconst10;
8247               real_from_integer (&dconst10, VOIDmode, 10, 0, 0);
8248               x = build_real (type, dconst10);
8249             }
8250             exponent = CALL_EXPR_ARG (arg, 0);
8251             break;
8252           CASE_FLT_FN (BUILT_IN_SQRT):
8253             /* Prepare to do logN(sqrt(x) -> 0.5*logN(x).  */
8254             x = CALL_EXPR_ARG (arg, 0);
8255             exponent = build_real (type, dconsthalf);
8256             break;
8257           CASE_FLT_FN (BUILT_IN_CBRT):
8258             /* Prepare to do logN(cbrt(x) -> (1/3)*logN(x).  */
8259             x = CALL_EXPR_ARG (arg, 0);
8260             exponent = build_real (type, real_value_truncate (TYPE_MODE (type),
8261                                                               dconst_third ()));
8262             break;
8263           CASE_FLT_FN (BUILT_IN_POW):
8264             /* Prepare to do logN(pow(x,exponent) -> exponent*logN(x).  */
8265             x = CALL_EXPR_ARG (arg, 0);
8266             exponent = CALL_EXPR_ARG (arg, 1);
8267             break;
8268           default:
8269             break;
8270           }
8271
8272           /* Now perform the optimization.  */
8273           if (x && exponent)
8274             {
8275               tree logfn = build_call_expr_loc (loc, fndecl, 1, x);
8276               return fold_build2_loc (loc, MULT_EXPR, type, exponent, logfn);
8277             }
8278         }
8279     }
8280
8281   return NULL_TREE;
8282 }
8283
8284 /* Fold a builtin function call to hypot, hypotf, or hypotl.  Return
8285    NULL_TREE if no simplification can be made.  */
8286
8287 static tree
8288 fold_builtin_hypot (location_t loc, tree fndecl,
8289                     tree arg0, tree arg1, tree type)
8290 {
8291   tree res, narg0, narg1;
8292
8293   if (!validate_arg (arg0, REAL_TYPE)
8294       || !validate_arg (arg1, REAL_TYPE))
8295     return NULL_TREE;
8296
8297   /* Calculate the result when the argument is a constant.  */
8298   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_hypot)))
8299     return res;
8300
8301   /* If either argument to hypot has a negate or abs, strip that off.
8302      E.g. hypot(-x,fabs(y)) -> hypot(x,y).  */
8303   narg0 = fold_strip_sign_ops (arg0);
8304   narg1 = fold_strip_sign_ops (arg1);
8305   if (narg0 || narg1)
8306     {
8307       return build_call_expr_loc (loc, fndecl, 2, narg0 ? narg0 : arg0,
8308                               narg1 ? narg1 : arg1);
8309     }
8310
8311   /* If either argument is zero, hypot is fabs of the other.  */
8312   if (real_zerop (arg0))
8313     return fold_build1_loc (loc, ABS_EXPR, type, arg1);
8314   else if (real_zerop (arg1))
8315     return fold_build1_loc (loc, ABS_EXPR, type, arg0);
8316
8317   /* hypot(x,x) -> fabs(x)*sqrt(2).  */
8318   if (flag_unsafe_math_optimizations
8319       && operand_equal_p (arg0, arg1, OEP_PURE_SAME))
8320     {
8321       const REAL_VALUE_TYPE sqrt2_trunc
8322         = real_value_truncate (TYPE_MODE (type), dconst_sqrt2 ());
8323       return fold_build2_loc (loc, MULT_EXPR, type,
8324                           fold_build1_loc (loc, ABS_EXPR, type, arg0),
8325                           build_real (type, sqrt2_trunc));
8326     }
8327
8328   return NULL_TREE;
8329 }
8330
8331
8332 /* Fold a builtin function call to pow, powf, or powl.  Return
8333    NULL_TREE if no simplification can be made.  */
8334 static tree
8335 fold_builtin_pow (location_t loc, tree fndecl, tree arg0, tree arg1, tree type)
8336 {
8337   tree res;
8338
8339   if (!validate_arg (arg0, REAL_TYPE)
8340        || !validate_arg (arg1, REAL_TYPE))
8341     return NULL_TREE;
8342
8343   /* Calculate the result when the argument is a constant.  */
8344   if ((res = do_mpfr_arg2 (arg0, arg1, type, mpfr_pow)))
8345     return res;
8346
8347   /* Optimize pow(1.0,y) = 1.0.  */
8348   if (real_onep (arg0))
8349     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8350
8351   if (TREE_CODE (arg1) == REAL_CST
8352       && !TREE_OVERFLOW (arg1))
8353     {
8354       REAL_VALUE_TYPE cint;
8355       REAL_VALUE_TYPE c;
8356       HOST_WIDE_INT n;
8357
8358       c = TREE_REAL_CST (arg1);
8359
8360       /* Optimize pow(x,0.0) = 1.0.  */
8361       if (REAL_VALUES_EQUAL (c, dconst0))
8362         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8363                                  arg0);
8364
8365       /* Optimize pow(x,1.0) = x.  */
8366       if (REAL_VALUES_EQUAL (c, dconst1))
8367         return arg0;
8368
8369       /* Optimize pow(x,-1.0) = 1.0/x.  */
8370       if (REAL_VALUES_EQUAL (c, dconstm1))
8371         return fold_build2_loc (loc, RDIV_EXPR, type,
8372                             build_real (type, dconst1), arg0);
8373
8374       /* Optimize pow(x,0.5) = sqrt(x).  */
8375       if (flag_unsafe_math_optimizations
8376           && REAL_VALUES_EQUAL (c, dconsthalf))
8377         {
8378           tree sqrtfn = mathfn_built_in (type, BUILT_IN_SQRT);
8379
8380           if (sqrtfn != NULL_TREE)
8381             return build_call_expr_loc (loc, sqrtfn, 1, arg0);
8382         }
8383
8384       /* Optimize pow(x,1.0/3.0) = cbrt(x).  */
8385       if (flag_unsafe_math_optimizations)
8386         {
8387           const REAL_VALUE_TYPE dconstroot
8388             = real_value_truncate (TYPE_MODE (type), dconst_third ());
8389
8390           if (REAL_VALUES_EQUAL (c, dconstroot))
8391             {
8392               tree cbrtfn = mathfn_built_in (type, BUILT_IN_CBRT);
8393               if (cbrtfn != NULL_TREE)
8394                 return build_call_expr_loc (loc, cbrtfn, 1, arg0);
8395             }
8396         }
8397
8398       /* Check for an integer exponent.  */
8399       n = real_to_integer (&c);
8400       real_from_integer (&cint, VOIDmode, n, n < 0 ? -1 : 0, 0);
8401       if (real_identical (&c, &cint))
8402         {
8403           /* Attempt to evaluate pow at compile-time, unless this should
8404              raise an exception.  */
8405           if (TREE_CODE (arg0) == REAL_CST
8406               && !TREE_OVERFLOW (arg0)
8407               && (n > 0
8408                   || (!flag_trapping_math && !flag_errno_math)
8409                   || !REAL_VALUES_EQUAL (TREE_REAL_CST (arg0), dconst0)))
8410             {
8411               REAL_VALUE_TYPE x;
8412               bool inexact;
8413
8414               x = TREE_REAL_CST (arg0);
8415               inexact = real_powi (&x, TYPE_MODE (type), &x, n);
8416               if (flag_unsafe_math_optimizations || !inexact)
8417                 return build_real (type, x);
8418             }
8419
8420           /* Strip sign ops from even integer powers.  */
8421           if ((n & 1) == 0 && flag_unsafe_math_optimizations)
8422             {
8423               tree narg0 = fold_strip_sign_ops (arg0);
8424               if (narg0)
8425                 return build_call_expr_loc (loc, fndecl, 2, narg0, arg1);
8426             }
8427         }
8428     }
8429
8430   if (flag_unsafe_math_optimizations)
8431     {
8432       const enum built_in_function fcode = builtin_mathfn_code (arg0);
8433
8434       /* Optimize pow(expN(x),y) = expN(x*y).  */
8435       if (BUILTIN_EXPONENT_P (fcode))
8436         {
8437           tree expfn = TREE_OPERAND (CALL_EXPR_FN (arg0), 0);
8438           tree arg = CALL_EXPR_ARG (arg0, 0);
8439           arg = fold_build2_loc (loc, MULT_EXPR, type, arg, arg1);
8440           return build_call_expr_loc (loc, expfn, 1, arg);
8441         }
8442
8443       /* Optimize pow(sqrt(x),y) = pow(x,y*0.5).  */
8444       if (BUILTIN_SQRT_P (fcode))
8445         {
8446           tree narg0 = CALL_EXPR_ARG (arg0, 0);
8447           tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8448                                     build_real (type, dconsthalf));
8449           return build_call_expr_loc (loc, fndecl, 2, narg0, narg1);
8450         }
8451
8452       /* Optimize pow(cbrt(x),y) = pow(x,y/3) iff x is nonnegative.  */
8453       if (BUILTIN_CBRT_P (fcode))
8454         {
8455           tree arg = CALL_EXPR_ARG (arg0, 0);
8456           if (tree_expr_nonnegative_p (arg))
8457             {
8458               const REAL_VALUE_TYPE dconstroot
8459                 = real_value_truncate (TYPE_MODE (type), dconst_third ());
8460               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg1,
8461                                         build_real (type, dconstroot));
8462               return build_call_expr_loc (loc, fndecl, 2, arg, narg1);
8463             }
8464         }
8465
8466       /* Optimize pow(pow(x,y),z) = pow(x,y*z) iff x is nonnegative.  */
8467       if (fcode == BUILT_IN_POW
8468           || fcode == BUILT_IN_POWF
8469           || fcode == BUILT_IN_POWL)
8470         {
8471           tree arg00 = CALL_EXPR_ARG (arg0, 0);
8472           if (tree_expr_nonnegative_p (arg00))
8473             {
8474               tree arg01 = CALL_EXPR_ARG (arg0, 1);
8475               tree narg1 = fold_build2_loc (loc, MULT_EXPR, type, arg01, arg1);
8476               return build_call_expr_loc (loc, fndecl, 2, arg00, narg1);
8477             }
8478         }
8479     }
8480
8481   return NULL_TREE;
8482 }
8483
8484 /* Fold a builtin function call to powi, powif, or powil with argument ARG.
8485    Return NULL_TREE if no simplification can be made.  */
8486 static tree
8487 fold_builtin_powi (location_t loc, tree fndecl ATTRIBUTE_UNUSED,
8488                    tree arg0, tree arg1, tree type)
8489 {
8490   if (!validate_arg (arg0, REAL_TYPE)
8491       || !validate_arg (arg1, INTEGER_TYPE))
8492     return NULL_TREE;
8493
8494   /* Optimize pow(1.0,y) = 1.0.  */
8495   if (real_onep (arg0))
8496     return omit_one_operand_loc (loc, type, build_real (type, dconst1), arg1);
8497
8498   if (host_integerp (arg1, 0))
8499     {
8500       HOST_WIDE_INT c = TREE_INT_CST_LOW (arg1);
8501
8502       /* Evaluate powi at compile-time.  */
8503       if (TREE_CODE (arg0) == REAL_CST
8504           && !TREE_OVERFLOW (arg0))
8505         {
8506           REAL_VALUE_TYPE x;
8507           x = TREE_REAL_CST (arg0);
8508           real_powi (&x, TYPE_MODE (type), &x, c);
8509           return build_real (type, x);
8510         }
8511
8512       /* Optimize pow(x,0) = 1.0.  */
8513       if (c == 0)
8514         return omit_one_operand_loc (loc, type, build_real (type, dconst1),
8515                                  arg0);
8516
8517       /* Optimize pow(x,1) = x.  */
8518       if (c == 1)
8519         return arg0;
8520
8521       /* Optimize pow(x,-1) = 1.0/x.  */
8522       if (c == -1)
8523         return fold_build2_loc (loc, RDIV_EXPR, type,
8524                            build_real (type, dconst1), arg0);
8525     }
8526
8527   return NULL_TREE;
8528 }
8529
8530 /* A subroutine of fold_builtin to fold the various exponent
8531    functions.  Return NULL_TREE if no simplification can be made.
8532    FUNC is the corresponding MPFR exponent function.  */
8533
8534 static tree
8535 fold_builtin_exponent (location_t loc, tree fndecl, tree arg,
8536                        int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t))
8537 {
8538   if (validate_arg (arg, REAL_TYPE))
8539     {
8540       tree type = TREE_TYPE (TREE_TYPE (fndecl));
8541       tree res;
8542
8543       /* Calculate the result when the argument is a constant.  */
8544       if ((res = do_mpfr_arg1 (arg, type, func, NULL, NULL, 0)))
8545         return res;
8546
8547       /* Optimize expN(logN(x)) = x.  */
8548       if (flag_unsafe_math_optimizations)
8549         {
8550           const enum built_in_function fcode = builtin_mathfn_code (arg);
8551
8552           if ((func == mpfr_exp
8553                && (fcode == BUILT_IN_LOG
8554                    || fcode == BUILT_IN_LOGF
8555                    || fcode == BUILT_IN_LOGL))
8556               || (func == mpfr_exp2
8557                   && (fcode == BUILT_IN_LOG2
8558                       || fcode == BUILT_IN_LOG2F
8559                       || fcode == BUILT_IN_LOG2L))
8560               || (func == mpfr_exp10
8561                   && (fcode == BUILT_IN_LOG10
8562                       || fcode == BUILT_IN_LOG10F
8563                       || fcode == BUILT_IN_LOG10L)))
8564             return fold_convert_loc (loc, type, CALL_EXPR_ARG (arg, 0));
8565         }
8566     }
8567
8568   return NULL_TREE;
8569 }
8570
8571 /* Return true if VAR is a VAR_DECL or a component thereof.  */
8572
8573 static bool
8574 var_decl_component_p (tree var)
8575 {
8576   tree inner = var;
8577   while (handled_component_p (inner))
8578     inner = TREE_OPERAND (inner, 0);
8579   return SSA_VAR_P (inner);
8580 }
8581
8582 /* Fold function call to builtin memset.  Return
8583    NULL_TREE if no simplification can be made.  */
8584
8585 static tree
8586 fold_builtin_memset (location_t loc, tree dest, tree c, tree len,
8587                      tree type, bool ignore)
8588 {
8589   tree var, ret, etype;
8590   unsigned HOST_WIDE_INT length, cval;
8591
8592   if (! validate_arg (dest, POINTER_TYPE)
8593       || ! validate_arg (c, INTEGER_TYPE)
8594       || ! validate_arg (len, INTEGER_TYPE))
8595     return NULL_TREE;
8596
8597   if (! host_integerp (len, 1))
8598     return NULL_TREE;
8599
8600   /* If the LEN parameter is zero, return DEST.  */
8601   if (integer_zerop (len))
8602     return omit_one_operand_loc (loc, type, dest, c);
8603
8604   if (TREE_CODE (c) != INTEGER_CST || TREE_SIDE_EFFECTS (dest))
8605     return NULL_TREE;
8606
8607   var = dest;
8608   STRIP_NOPS (var);
8609   if (TREE_CODE (var) != ADDR_EXPR)
8610     return NULL_TREE;
8611
8612   var = TREE_OPERAND (var, 0);
8613   if (TREE_THIS_VOLATILE (var))
8614     return NULL_TREE;
8615
8616   etype = TREE_TYPE (var);
8617   if (TREE_CODE (etype) == ARRAY_TYPE)
8618     etype = TREE_TYPE (etype);
8619
8620   if (!INTEGRAL_TYPE_P (etype)
8621       && !POINTER_TYPE_P (etype))
8622     return NULL_TREE;
8623
8624   if (! var_decl_component_p (var))
8625     return NULL_TREE;
8626
8627   length = tree_low_cst (len, 1);
8628   if (GET_MODE_SIZE (TYPE_MODE (etype)) != length
8629       || get_pointer_alignment (dest) / BITS_PER_UNIT < length)
8630     return NULL_TREE;
8631
8632   if (length > HOST_BITS_PER_WIDE_INT / BITS_PER_UNIT)
8633     return NULL_TREE;
8634
8635   if (integer_zerop (c))
8636     cval = 0;
8637   else
8638     {
8639       if (CHAR_BIT != 8 || BITS_PER_UNIT != 8 || HOST_BITS_PER_WIDE_INT > 64)
8640         return NULL_TREE;
8641
8642       cval = TREE_INT_CST_LOW (c);
8643       cval &= 0xff;
8644       cval |= cval << 8;
8645       cval |= cval << 16;
8646       cval |= (cval << 31) << 1;
8647     }
8648
8649   ret = build_int_cst_type (etype, cval);
8650   var = build_fold_indirect_ref_loc (loc,
8651                                  fold_convert_loc (loc,
8652                                                    build_pointer_type (etype),
8653                                                    dest));
8654   ret = build2 (MODIFY_EXPR, etype, var, ret);
8655   if (ignore)
8656     return ret;
8657
8658   return omit_one_operand_loc (loc, type, dest, ret);
8659 }
8660
8661 /* Fold function call to builtin memset.  Return
8662    NULL_TREE if no simplification can be made.  */
8663
8664 static tree
8665 fold_builtin_bzero (location_t loc, tree dest, tree size, bool ignore)
8666 {
8667   if (! validate_arg (dest, POINTER_TYPE)
8668       || ! validate_arg (size, INTEGER_TYPE))
8669     return NULL_TREE;
8670
8671   if (!ignore)
8672     return NULL_TREE;
8673
8674   /* New argument list transforming bzero(ptr x, int y) to
8675      memset(ptr x, int 0, size_t y).   This is done this way
8676      so that if it isn't expanded inline, we fallback to
8677      calling bzero instead of memset.  */
8678
8679   return fold_builtin_memset (loc, dest, integer_zero_node,
8680                               fold_convert_loc (loc, size_type_node, size),
8681                               void_type_node, ignore);
8682 }
8683
8684 /* Fold function call to builtin mem{{,p}cpy,move}.  Return
8685    NULL_TREE if no simplification can be made.
8686    If ENDP is 0, return DEST (like memcpy).
8687    If ENDP is 1, return DEST+LEN (like mempcpy).
8688    If ENDP is 2, return DEST+LEN-1 (like stpcpy).
8689    If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap
8690    (memmove).   */
8691
8692 static tree
8693 fold_builtin_memory_op (location_t loc, tree dest, tree src,
8694                         tree len, tree type, bool ignore, int endp)
8695 {
8696   tree destvar, srcvar, expr;
8697
8698   if (! validate_arg (dest, POINTER_TYPE)
8699       || ! validate_arg (src, POINTER_TYPE)
8700       || ! validate_arg (len, INTEGER_TYPE))
8701     return NULL_TREE;
8702
8703   /* If the LEN parameter is zero, return DEST.  */
8704   if (integer_zerop (len))
8705     return omit_one_operand_loc (loc, type, dest, src);
8706
8707   /* If SRC and DEST are the same (and not volatile), return
8708      DEST{,+LEN,+LEN-1}.  */
8709   if (operand_equal_p (src, dest, 0))
8710     expr = len;
8711   else
8712     {
8713       tree srctype, desttype;
8714       unsigned int src_align, dest_align;
8715       tree off0;
8716
8717       if (endp == 3)
8718         {
8719           src_align = get_pointer_alignment (src);
8720           dest_align = get_pointer_alignment (dest);
8721
8722           /* Both DEST and SRC must be pointer types.
8723              ??? This is what old code did.  Is the testing for pointer types
8724              really mandatory?
8725
8726              If either SRC is readonly or length is 1, we can use memcpy.  */
8727           if (!dest_align || !src_align)
8728             return NULL_TREE;
8729           if (readonly_data_expr (src)
8730               || (host_integerp (len, 1)
8731                   && (MIN (src_align, dest_align) / BITS_PER_UNIT
8732                       >= (unsigned HOST_WIDE_INT) tree_low_cst (len, 1))))
8733             {
8734               tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
8735               if (!fn)
8736                 return NULL_TREE;
8737               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8738             }
8739
8740           /* If *src and *dest can't overlap, optimize into memcpy as well.  */
8741           if (TREE_CODE (src) == ADDR_EXPR
8742               && TREE_CODE (dest) == ADDR_EXPR)
8743             {
8744               tree src_base, dest_base, fn;
8745               HOST_WIDE_INT src_offset = 0, dest_offset = 0;
8746               HOST_WIDE_INT size = -1;
8747               HOST_WIDE_INT maxsize = -1;
8748
8749               srcvar = TREE_OPERAND (src, 0);
8750               src_base = get_ref_base_and_extent (srcvar, &src_offset,
8751                                                   &size, &maxsize);
8752               destvar = TREE_OPERAND (dest, 0);
8753               dest_base = get_ref_base_and_extent (destvar, &dest_offset,
8754                                                    &size, &maxsize);
8755               if (host_integerp (len, 1))
8756                 maxsize = tree_low_cst (len, 1);
8757               else
8758                 maxsize = -1;
8759               src_offset /= BITS_PER_UNIT;
8760               dest_offset /= BITS_PER_UNIT;
8761               if (SSA_VAR_P (src_base)
8762                   && SSA_VAR_P (dest_base))
8763                 {
8764                   if (operand_equal_p (src_base, dest_base, 0)
8765                       && ranges_overlap_p (src_offset, maxsize,
8766                                            dest_offset, maxsize))
8767                     return NULL_TREE;
8768                 }
8769               else if (TREE_CODE (src_base) == MEM_REF
8770                        && TREE_CODE (dest_base) == MEM_REF)
8771                 {
8772                   double_int off;
8773                   if (! operand_equal_p (TREE_OPERAND (src_base, 0),
8774                                          TREE_OPERAND (dest_base, 0), 0))
8775                     return NULL_TREE;
8776                   off = double_int_add (mem_ref_offset (src_base),
8777                                         shwi_to_double_int (src_offset));
8778                   if (!double_int_fits_in_shwi_p (off))
8779                     return NULL_TREE;
8780                   src_offset = off.low;
8781                   off = double_int_add (mem_ref_offset (dest_base),
8782                                         shwi_to_double_int (dest_offset));
8783                   if (!double_int_fits_in_shwi_p (off))
8784                     return NULL_TREE;
8785                   dest_offset = off.low;
8786                   if (ranges_overlap_p (src_offset, maxsize,
8787                                         dest_offset, maxsize))
8788                     return NULL_TREE;
8789                 }
8790               else
8791                 return NULL_TREE;
8792
8793               fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
8794               if (!fn)
8795                 return NULL_TREE;
8796               return build_call_expr_loc (loc, fn, 3, dest, src, len);
8797             }
8798
8799           /* If the destination and source do not alias optimize into
8800              memcpy as well.  */
8801           if ((is_gimple_min_invariant (dest)
8802                || TREE_CODE (dest) == SSA_NAME)
8803               && (is_gimple_min_invariant (src)
8804                   || TREE_CODE (src) == SSA_NAME))
8805             {
8806               ao_ref destr, srcr;
8807               ao_ref_init_from_ptr_and_size (&destr, dest, len);
8808               ao_ref_init_from_ptr_and_size (&srcr, src, len);
8809               if (!refs_may_alias_p_1 (&destr, &srcr, false))
8810                 {
8811                   tree fn;
8812                   fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
8813                   if (!fn)
8814                     return NULL_TREE;
8815                   return build_call_expr_loc (loc, fn, 3, dest, src, len);
8816                 }
8817             }
8818
8819           return NULL_TREE;
8820         }
8821
8822       if (!host_integerp (len, 0))
8823         return NULL_TREE;
8824       /* FIXME:
8825          This logic lose for arguments like (type *)malloc (sizeof (type)),
8826          since we strip the casts of up to VOID return value from malloc.
8827          Perhaps we ought to inherit type from non-VOID argument here?  */
8828       STRIP_NOPS (src);
8829       STRIP_NOPS (dest);
8830       if (!POINTER_TYPE_P (TREE_TYPE (src))
8831           || !POINTER_TYPE_P (TREE_TYPE (dest)))
8832         return NULL_TREE;
8833       /* As we fold (void *)(p + CST) to (void *)p + CST undo this here.  */
8834       if (TREE_CODE (src) == POINTER_PLUS_EXPR)
8835         {
8836           tree tem = TREE_OPERAND (src, 0);
8837           STRIP_NOPS (tem);
8838           if (tem != TREE_OPERAND (src, 0))
8839             src = build1 (NOP_EXPR, TREE_TYPE (tem), src);
8840         }
8841       if (TREE_CODE (dest) == POINTER_PLUS_EXPR)
8842         {
8843           tree tem = TREE_OPERAND (dest, 0);
8844           STRIP_NOPS (tem);
8845           if (tem != TREE_OPERAND (dest, 0))
8846             dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest);
8847         }
8848       srctype = TREE_TYPE (TREE_TYPE (src));
8849       if (TREE_CODE (srctype) == ARRAY_TYPE
8850           && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8851         {
8852           srctype = TREE_TYPE (srctype);
8853           STRIP_NOPS (src);
8854           src = build1 (NOP_EXPR, build_pointer_type (srctype), src);
8855         }
8856       desttype = TREE_TYPE (TREE_TYPE (dest));
8857       if (TREE_CODE (desttype) == ARRAY_TYPE
8858           && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8859         {
8860           desttype = TREE_TYPE (desttype);
8861           STRIP_NOPS (dest);
8862           dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest);
8863         }
8864       if (TREE_ADDRESSABLE (srctype)
8865           || TREE_ADDRESSABLE (desttype))
8866         return NULL_TREE;
8867
8868       src_align = get_pointer_alignment (src);
8869       dest_align = get_pointer_alignment (dest);
8870       if (dest_align < TYPE_ALIGN (desttype)
8871           || src_align < TYPE_ALIGN (srctype))
8872         return NULL_TREE;
8873
8874       if (!ignore)
8875         dest = builtin_save_expr (dest);
8876
8877       /* Build accesses at offset zero with a ref-all character type.  */
8878       off0 = build_int_cst (build_pointer_type_for_mode (char_type_node,
8879                                                          ptr_mode, true), 0);
8880
8881       destvar = dest;
8882       STRIP_NOPS (destvar);
8883       if (TREE_CODE (destvar) == ADDR_EXPR
8884           && var_decl_component_p (TREE_OPERAND (destvar, 0))
8885           && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len))
8886         destvar = fold_build2 (MEM_REF, desttype, destvar, off0);
8887       else
8888         destvar = NULL_TREE;
8889
8890       srcvar = src;
8891       STRIP_NOPS (srcvar);
8892       if (TREE_CODE (srcvar) == ADDR_EXPR
8893           && var_decl_component_p (TREE_OPERAND (srcvar, 0))
8894           && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len))
8895         {
8896           if (!destvar
8897               || src_align >= TYPE_ALIGN (desttype))
8898             srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype,
8899                                   srcvar, off0);
8900           else if (!STRICT_ALIGNMENT)
8901             {
8902               srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8903                                             src_align);
8904               srcvar = fold_build2 (MEM_REF, srctype, srcvar, off0);
8905             }
8906           else
8907             srcvar = NULL_TREE;
8908         }
8909       else
8910         srcvar = NULL_TREE;
8911
8912       if (srcvar == NULL_TREE && destvar == NULL_TREE)
8913         return NULL_TREE;
8914
8915       if (srcvar == NULL_TREE)
8916         {
8917           STRIP_NOPS (src);
8918           if (src_align >= TYPE_ALIGN (desttype))
8919             srcvar = fold_build2 (MEM_REF, desttype, src, off0);
8920           else
8921             {
8922               if (STRICT_ALIGNMENT)
8923                 return NULL_TREE;
8924               srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype),
8925                                             src_align);
8926               srcvar = fold_build2 (MEM_REF, srctype, src, off0);
8927             }
8928         }
8929       else if (destvar == NULL_TREE)
8930         {
8931           STRIP_NOPS (dest);
8932           if (dest_align >= TYPE_ALIGN (srctype))
8933             destvar = fold_build2 (MEM_REF, srctype, dest, off0);
8934           else
8935             {
8936               if (STRICT_ALIGNMENT)
8937                 return NULL_TREE;
8938               desttype = build_aligned_type (TYPE_MAIN_VARIANT (srctype),
8939                                              dest_align);
8940               destvar = fold_build2 (MEM_REF, desttype, dest, off0);
8941             }
8942         }
8943
8944       expr = build2 (MODIFY_EXPR, TREE_TYPE (destvar), destvar, srcvar);
8945     }
8946
8947   if (ignore)
8948     return expr;
8949
8950   if (endp == 0 || endp == 3)
8951     return omit_one_operand_loc (loc, type, dest, expr);
8952
8953   if (expr == len)
8954     expr = NULL_TREE;
8955
8956   if (endp == 2)
8957     len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len,
8958                        ssize_int (1));
8959
8960   dest = fold_build_pointer_plus_loc (loc, dest, len);
8961   dest = fold_convert_loc (loc, type, dest);
8962   if (expr)
8963     dest = omit_one_operand_loc (loc, type, dest, expr);
8964   return dest;
8965 }
8966
8967 /* Fold function call to builtin strcpy with arguments DEST and SRC.
8968    If LEN is not NULL, it represents the length of the string to be
8969    copied.  Return NULL_TREE if no simplification can be made.  */
8970
8971 tree
8972 fold_builtin_strcpy (location_t loc, tree fndecl, tree dest, tree src, tree len)
8973 {
8974   tree fn;
8975
8976   if (!validate_arg (dest, POINTER_TYPE)
8977       || !validate_arg (src, POINTER_TYPE))
8978     return NULL_TREE;
8979
8980   /* If SRC and DEST are the same (and not volatile), return DEST.  */
8981   if (operand_equal_p (src, dest, 0))
8982     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
8983
8984   if (optimize_function_for_size_p (cfun))
8985     return NULL_TREE;
8986
8987   fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
8988   if (!fn)
8989     return NULL_TREE;
8990
8991   if (!len)
8992     {
8993       len = c_strlen (src, 1);
8994       if (! len || TREE_SIDE_EFFECTS (len))
8995         return NULL_TREE;
8996     }
8997
8998   len = fold_convert_loc (loc, size_type_node, len);
8999   len = size_binop_loc (loc, PLUS_EXPR, len, build_int_cst (size_type_node, 1));
9000   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
9001                            build_call_expr_loc (loc, fn, 3, dest, src, len));
9002 }
9003
9004 /* Fold function call to builtin stpcpy with arguments DEST and SRC.
9005    Return NULL_TREE if no simplification can be made.  */
9006
9007 static tree
9008 fold_builtin_stpcpy (location_t loc, tree fndecl, tree dest, tree src)
9009 {
9010   tree fn, len, lenp1, call, type;
9011
9012   if (!validate_arg (dest, POINTER_TYPE)
9013       || !validate_arg (src, POINTER_TYPE))
9014     return NULL_TREE;
9015
9016   len = c_strlen (src, 1);
9017   if (!len
9018       || TREE_CODE (len) != INTEGER_CST)
9019     return NULL_TREE;
9020
9021   if (optimize_function_for_size_p (cfun)
9022       /* If length is zero it's small enough.  */
9023       && !integer_zerop (len))
9024     return NULL_TREE;
9025
9026   fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
9027   if (!fn)
9028     return NULL_TREE;
9029
9030   lenp1 = size_binop_loc (loc, PLUS_EXPR,
9031                           fold_convert_loc (loc, size_type_node, len),
9032                           build_int_cst (size_type_node, 1));
9033   /* We use dest twice in building our expression.  Save it from
9034      multiple expansions.  */
9035   dest = builtin_save_expr (dest);
9036   call = build_call_expr_loc (loc, fn, 3, dest, src, lenp1);
9037
9038   type = TREE_TYPE (TREE_TYPE (fndecl));
9039   dest = fold_build_pointer_plus_loc (loc, dest, len);
9040   dest = fold_convert_loc (loc, type, dest);
9041   dest = omit_one_operand_loc (loc, type, dest, call);
9042   return dest;
9043 }
9044
9045 /* Fold function call to builtin strncpy with arguments DEST, SRC, and LEN.
9046    If SLEN is not NULL, it represents the length of the source string.
9047    Return NULL_TREE if no simplification can be made.  */
9048
9049 tree
9050 fold_builtin_strncpy (location_t loc, tree fndecl, tree dest,
9051                       tree src, tree len, tree slen)
9052 {
9053   tree fn;
9054
9055   if (!validate_arg (dest, POINTER_TYPE)
9056       || !validate_arg (src, POINTER_TYPE)
9057       || !validate_arg (len, INTEGER_TYPE))
9058     return NULL_TREE;
9059
9060   /* If the LEN parameter is zero, return DEST.  */
9061   if (integer_zerop (len))
9062     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
9063
9064   /* We can't compare slen with len as constants below if len is not a
9065      constant.  */
9066   if (len == 0 || TREE_CODE (len) != INTEGER_CST)
9067     return NULL_TREE;
9068
9069   if (!slen)
9070     slen = c_strlen (src, 1);
9071
9072   /* Now, we must be passed a constant src ptr parameter.  */
9073   if (slen == 0 || TREE_CODE (slen) != INTEGER_CST)
9074     return NULL_TREE;
9075
9076   slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
9077
9078   /* We do not support simplification of this case, though we do
9079      support it when expanding trees into RTL.  */
9080   /* FIXME: generate a call to __builtin_memset.  */
9081   if (tree_int_cst_lt (slen, len))
9082     return NULL_TREE;
9083
9084   /* OK transform into builtin memcpy.  */
9085   fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
9086   if (!fn)
9087     return NULL_TREE;
9088
9089   len = fold_convert_loc (loc, size_type_node, len);
9090   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
9091                            build_call_expr_loc (loc, fn, 3, dest, src, len));
9092 }
9093
9094 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
9095    arguments to the call, and TYPE is its return type.
9096    Return NULL_TREE if no simplification can be made.  */
9097
9098 static tree
9099 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
9100 {
9101   if (!validate_arg (arg1, POINTER_TYPE)
9102       || !validate_arg (arg2, INTEGER_TYPE)
9103       || !validate_arg (len, INTEGER_TYPE))
9104     return NULL_TREE;
9105   else
9106     {
9107       const char *p1;
9108
9109       if (TREE_CODE (arg2) != INTEGER_CST
9110           || !host_integerp (len, 1))
9111         return NULL_TREE;
9112
9113       p1 = c_getstr (arg1);
9114       if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
9115         {
9116           char c;
9117           const char *r;
9118           tree tem;
9119
9120           if (target_char_cast (arg2, &c))
9121             return NULL_TREE;
9122
9123           r = (const char *) memchr (p1, c, tree_low_cst (len, 1));
9124
9125           if (r == NULL)
9126             return build_int_cst (TREE_TYPE (arg1), 0);
9127
9128           tem = fold_build_pointer_plus_hwi_loc (loc, arg1, r - p1);
9129           return fold_convert_loc (loc, type, tem);
9130         }
9131       return NULL_TREE;
9132     }
9133 }
9134
9135 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
9136    Return NULL_TREE if no simplification can be made.  */
9137
9138 static tree
9139 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
9140 {
9141   const char *p1, *p2;
9142
9143   if (!validate_arg (arg1, POINTER_TYPE)
9144       || !validate_arg (arg2, POINTER_TYPE)
9145       || !validate_arg (len, INTEGER_TYPE))
9146     return NULL_TREE;
9147
9148   /* If the LEN parameter is zero, return zero.  */
9149   if (integer_zerop (len))
9150     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
9151                               arg1, arg2);
9152
9153   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
9154   if (operand_equal_p (arg1, arg2, 0))
9155     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
9156
9157   p1 = c_getstr (arg1);
9158   p2 = c_getstr (arg2);
9159
9160   /* If all arguments are constant, and the value of len is not greater
9161      than the lengths of arg1 and arg2, evaluate at compile-time.  */
9162   if (host_integerp (len, 1) && p1 && p2
9163       && compare_tree_int (len, strlen (p1) + 1) <= 0
9164       && compare_tree_int (len, strlen (p2) + 1) <= 0)
9165     {
9166       const int r = memcmp (p1, p2, tree_low_cst (len, 1));
9167
9168       if (r > 0)
9169         return integer_one_node;
9170       else if (r < 0)
9171         return integer_minus_one_node;
9172       else
9173         return integer_zero_node;
9174     }
9175
9176   /* If len parameter is one, return an expression corresponding to
9177      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
9178   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9179     {
9180       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9181       tree cst_uchar_ptr_node
9182         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9183
9184       tree ind1
9185         = fold_convert_loc (loc, integer_type_node,
9186                             build1 (INDIRECT_REF, cst_uchar_node,
9187                                     fold_convert_loc (loc,
9188                                                       cst_uchar_ptr_node,
9189                                                       arg1)));
9190       tree ind2
9191         = fold_convert_loc (loc, integer_type_node,
9192                             build1 (INDIRECT_REF, cst_uchar_node,
9193                                     fold_convert_loc (loc,
9194                                                       cst_uchar_ptr_node,
9195                                                       arg2)));
9196       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9197     }
9198
9199   return NULL_TREE;
9200 }
9201
9202 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
9203    Return NULL_TREE if no simplification can be made.  */
9204
9205 static tree
9206 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
9207 {
9208   const char *p1, *p2;
9209
9210   if (!validate_arg (arg1, POINTER_TYPE)
9211       || !validate_arg (arg2, POINTER_TYPE))
9212     return NULL_TREE;
9213
9214   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
9215   if (operand_equal_p (arg1, arg2, 0))
9216     return integer_zero_node;
9217
9218   p1 = c_getstr (arg1);
9219   p2 = c_getstr (arg2);
9220
9221   if (p1 && p2)
9222     {
9223       const int i = strcmp (p1, p2);
9224       if (i < 0)
9225         return integer_minus_one_node;
9226       else if (i > 0)
9227         return integer_one_node;
9228       else
9229         return integer_zero_node;
9230     }
9231
9232   /* If the second arg is "", return *(const unsigned char*)arg1.  */
9233   if (p2 && *p2 == '\0')
9234     {
9235       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9236       tree cst_uchar_ptr_node
9237         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9238
9239       return fold_convert_loc (loc, integer_type_node,
9240                                build1 (INDIRECT_REF, cst_uchar_node,
9241                                        fold_convert_loc (loc,
9242                                                          cst_uchar_ptr_node,
9243                                                          arg1)));
9244     }
9245
9246   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
9247   if (p1 && *p1 == '\0')
9248     {
9249       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9250       tree cst_uchar_ptr_node
9251         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9252
9253       tree temp
9254         = fold_convert_loc (loc, integer_type_node,
9255                             build1 (INDIRECT_REF, cst_uchar_node,
9256                                     fold_convert_loc (loc,
9257                                                       cst_uchar_ptr_node,
9258                                                       arg2)));
9259       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9260     }
9261
9262   return NULL_TREE;
9263 }
9264
9265 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
9266    Return NULL_TREE if no simplification can be made.  */
9267
9268 static tree
9269 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
9270 {
9271   const char *p1, *p2;
9272
9273   if (!validate_arg (arg1, POINTER_TYPE)
9274       || !validate_arg (arg2, POINTER_TYPE)
9275       || !validate_arg (len, INTEGER_TYPE))
9276     return NULL_TREE;
9277
9278   /* If the LEN parameter is zero, return zero.  */
9279   if (integer_zerop (len))
9280     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
9281                               arg1, arg2);
9282
9283   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
9284   if (operand_equal_p (arg1, arg2, 0))
9285     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
9286
9287   p1 = c_getstr (arg1);
9288   p2 = c_getstr (arg2);
9289
9290   if (host_integerp (len, 1) && p1 && p2)
9291     {
9292       const int i = strncmp (p1, p2, tree_low_cst (len, 1));
9293       if (i > 0)
9294         return integer_one_node;
9295       else if (i < 0)
9296         return integer_minus_one_node;
9297       else
9298         return integer_zero_node;
9299     }
9300
9301   /* If the second arg is "", and the length is greater than zero,
9302      return *(const unsigned char*)arg1.  */
9303   if (p2 && *p2 == '\0'
9304       && TREE_CODE (len) == INTEGER_CST
9305       && tree_int_cst_sgn (len) == 1)
9306     {
9307       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9308       tree cst_uchar_ptr_node
9309         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9310
9311       return fold_convert_loc (loc, integer_type_node,
9312                                build1 (INDIRECT_REF, cst_uchar_node,
9313                                        fold_convert_loc (loc,
9314                                                          cst_uchar_ptr_node,
9315                                                          arg1)));
9316     }
9317
9318   /* If the first arg is "", and the length is greater than zero,
9319      return -*(const unsigned char*)arg2.  */
9320   if (p1 && *p1 == '\0'
9321       && TREE_CODE (len) == INTEGER_CST
9322       && tree_int_cst_sgn (len) == 1)
9323     {
9324       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9325       tree cst_uchar_ptr_node
9326         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9327
9328       tree temp = fold_convert_loc (loc, integer_type_node,
9329                                     build1 (INDIRECT_REF, cst_uchar_node,
9330                                             fold_convert_loc (loc,
9331                                                               cst_uchar_ptr_node,
9332                                                               arg2)));
9333       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
9334     }
9335
9336   /* If len parameter is one, return an expression corresponding to
9337      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
9338   if (host_integerp (len, 1) && tree_low_cst (len, 1) == 1)
9339     {
9340       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
9341       tree cst_uchar_ptr_node
9342         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
9343
9344       tree ind1 = fold_convert_loc (loc, integer_type_node,
9345                                     build1 (INDIRECT_REF, cst_uchar_node,
9346                                             fold_convert_loc (loc,
9347                                                               cst_uchar_ptr_node,
9348                                                               arg1)));
9349       tree ind2 = fold_convert_loc (loc, integer_type_node,
9350                                     build1 (INDIRECT_REF, cst_uchar_node,
9351                                             fold_convert_loc (loc,
9352                                                               cst_uchar_ptr_node,
9353                                                               arg2)));
9354       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
9355     }
9356
9357   return NULL_TREE;
9358 }
9359
9360 /* Fold function call to builtin signbit, signbitf or signbitl with argument
9361    ARG.  Return NULL_TREE if no simplification can be made.  */
9362
9363 static tree
9364 fold_builtin_signbit (location_t loc, tree arg, tree type)
9365 {
9366   if (!validate_arg (arg, REAL_TYPE))
9367     return NULL_TREE;
9368
9369   /* If ARG is a compile-time constant, determine the result.  */
9370   if (TREE_CODE (arg) == REAL_CST
9371       && !TREE_OVERFLOW (arg))
9372     {
9373       REAL_VALUE_TYPE c;
9374
9375       c = TREE_REAL_CST (arg);
9376       return (REAL_VALUE_NEGATIVE (c)
9377               ? build_one_cst (type)
9378               : build_zero_cst (type));
9379     }
9380
9381   /* If ARG is non-negative, the result is always zero.  */
9382   if (tree_expr_nonnegative_p (arg))
9383     return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9384
9385   /* If ARG's format doesn't have signed zeros, return "arg < 0.0".  */
9386   if (!HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg))))
9387     return fold_convert (type,
9388                          fold_build2_loc (loc, LT_EXPR, boolean_type_node, arg,
9389                         build_real (TREE_TYPE (arg), dconst0)));
9390
9391   return NULL_TREE;
9392 }
9393
9394 /* Fold function call to builtin copysign, copysignf or copysignl with
9395    arguments ARG1 and ARG2.  Return NULL_TREE if no simplification can
9396    be made.  */
9397
9398 static tree
9399 fold_builtin_copysign (location_t loc, tree fndecl,
9400                        tree arg1, tree arg2, tree type)
9401 {
9402   tree tem;
9403
9404   if (!validate_arg (arg1, REAL_TYPE)
9405       || !validate_arg (arg2, REAL_TYPE))
9406     return NULL_TREE;
9407
9408   /* copysign(X,X) is X.  */
9409   if (operand_equal_p (arg1, arg2, 0))
9410     return fold_convert_loc (loc, type, arg1);
9411
9412   /* If ARG1 and ARG2 are compile-time constants, determine the result.  */
9413   if (TREE_CODE (arg1) == REAL_CST
9414       && TREE_CODE (arg2) == REAL_CST
9415       && !TREE_OVERFLOW (arg1)
9416       && !TREE_OVERFLOW (arg2))
9417     {
9418       REAL_VALUE_TYPE c1, c2;
9419
9420       c1 = TREE_REAL_CST (arg1);
9421       c2 = TREE_REAL_CST (arg2);
9422       /* c1.sign := c2.sign.  */
9423       real_copysign (&c1, &c2);
9424       return build_real (type, c1);
9425     }
9426
9427   /* copysign(X, Y) is fabs(X) when Y is always non-negative.
9428      Remember to evaluate Y for side-effects.  */
9429   if (tree_expr_nonnegative_p (arg2))
9430     return omit_one_operand_loc (loc, type,
9431                              fold_build1_loc (loc, ABS_EXPR, type, arg1),
9432                              arg2);
9433
9434   /* Strip sign changing operations for the first argument.  */
9435   tem = fold_strip_sign_ops (arg1);
9436   if (tem)
9437     return build_call_expr_loc (loc, fndecl, 2, tem, arg2);
9438
9439   return NULL_TREE;
9440 }
9441
9442 /* Fold a call to builtin isascii with argument ARG.  */
9443
9444 static tree
9445 fold_builtin_isascii (location_t loc, tree arg)
9446 {
9447   if (!validate_arg (arg, INTEGER_TYPE))
9448     return NULL_TREE;
9449   else
9450     {
9451       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
9452       arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
9453                          build_int_cst (integer_type_node,
9454                                         ~ (unsigned HOST_WIDE_INT) 0x7f));
9455       return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
9456                               arg, integer_zero_node);
9457     }
9458 }
9459
9460 /* Fold a call to builtin toascii with argument ARG.  */
9461
9462 static tree
9463 fold_builtin_toascii (location_t loc, tree arg)
9464 {
9465   if (!validate_arg (arg, INTEGER_TYPE))
9466     return NULL_TREE;
9467
9468   /* Transform toascii(c) -> (c & 0x7f).  */
9469   return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
9470                           build_int_cst (integer_type_node, 0x7f));
9471 }
9472
9473 /* Fold a call to builtin isdigit with argument ARG.  */
9474
9475 static tree
9476 fold_builtin_isdigit (location_t loc, tree arg)
9477 {
9478   if (!validate_arg (arg, INTEGER_TYPE))
9479     return NULL_TREE;
9480   else
9481     {
9482       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
9483       /* According to the C standard, isdigit is unaffected by locale.
9484          However, it definitely is affected by the target character set.  */
9485       unsigned HOST_WIDE_INT target_digit0
9486         = lang_hooks.to_target_charset ('0');
9487
9488       if (target_digit0 == 0)
9489         return NULL_TREE;
9490
9491       arg = fold_convert_loc (loc, unsigned_type_node, arg);
9492       arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
9493                          build_int_cst (unsigned_type_node, target_digit0));
9494       return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
9495                           build_int_cst (unsigned_type_node, 9));
9496     }
9497 }
9498
9499 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
9500
9501 static tree
9502 fold_builtin_fabs (location_t loc, tree arg, tree type)
9503 {
9504   if (!validate_arg (arg, REAL_TYPE))
9505     return NULL_TREE;
9506
9507   arg = fold_convert_loc (loc, type, arg);
9508   if (TREE_CODE (arg) == REAL_CST)
9509     return fold_abs_const (arg, type);
9510   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9511 }
9512
9513 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
9514
9515 static tree
9516 fold_builtin_abs (location_t loc, tree arg, tree type)
9517 {
9518   if (!validate_arg (arg, INTEGER_TYPE))
9519     return NULL_TREE;
9520
9521   arg = fold_convert_loc (loc, type, arg);
9522   if (TREE_CODE (arg) == INTEGER_CST)
9523     return fold_abs_const (arg, type);
9524   return fold_build1_loc (loc, ABS_EXPR, type, arg);
9525 }
9526
9527 /* Fold a fma operation with arguments ARG[012].  */
9528
9529 tree
9530 fold_fma (location_t loc ATTRIBUTE_UNUSED,
9531           tree type, tree arg0, tree arg1, tree arg2)
9532 {
9533   if (TREE_CODE (arg0) == REAL_CST
9534       && TREE_CODE (arg1) == REAL_CST
9535       && TREE_CODE (arg2) == REAL_CST)
9536     return do_mpfr_arg3 (arg0, arg1, arg2, type, mpfr_fma);
9537
9538   return NULL_TREE;
9539 }
9540
9541 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012].  */
9542
9543 static tree
9544 fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type)
9545 {
9546   if (validate_arg (arg0, REAL_TYPE)
9547       && validate_arg(arg1, REAL_TYPE)
9548       && validate_arg(arg2, REAL_TYPE))
9549     {
9550       tree tem = fold_fma (loc, type, arg0, arg1, arg2);
9551       if (tem)
9552         return tem;
9553
9554       /* ??? Only expand to FMA_EXPR if it's directly supported.  */
9555       if (optab_handler (fma_optab, TYPE_MODE (type)) != CODE_FOR_nothing)
9556         return fold_build3_loc (loc, FMA_EXPR, type, arg0, arg1, arg2);
9557     }
9558   return NULL_TREE;
9559 }
9560
9561 /* Fold a call to builtin fmin or fmax.  */
9562
9563 static tree
9564 fold_builtin_fmin_fmax (location_t loc, tree arg0, tree arg1,
9565                         tree type, bool max)
9566 {
9567   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, REAL_TYPE))
9568     {
9569       /* Calculate the result when the argument is a constant.  */
9570       tree res = do_mpfr_arg2 (arg0, arg1, type, (max ? mpfr_max : mpfr_min));
9571
9572       if (res)
9573         return res;
9574
9575       /* If either argument is NaN, return the other one.  Avoid the
9576          transformation if we get (and honor) a signalling NaN.  Using
9577          omit_one_operand() ensures we create a non-lvalue.  */
9578       if (TREE_CODE (arg0) == REAL_CST
9579           && real_isnan (&TREE_REAL_CST (arg0))
9580           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
9581               || ! TREE_REAL_CST (arg0).signalling))
9582         return omit_one_operand_loc (loc, type, arg1, arg0);
9583       if (TREE_CODE (arg1) == REAL_CST
9584           && real_isnan (&TREE_REAL_CST (arg1))
9585           && (! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1)))
9586               || ! TREE_REAL_CST (arg1).signalling))
9587         return omit_one_operand_loc (loc, type, arg0, arg1);
9588
9589       /* Transform fmin/fmax(x,x) -> x.  */
9590       if (operand_equal_p (arg0, arg1, OEP_PURE_SAME))
9591         return omit_one_operand_loc (loc, type, arg0, arg1);
9592
9593       /* Convert fmin/fmax to MIN_EXPR/MAX_EXPR.  C99 requires these
9594          functions to return the numeric arg if the other one is NaN.
9595          These tree codes don't honor that, so only transform if
9596          -ffinite-math-only is set.  C99 doesn't require -0.0 to be
9597          handled, so we don't have to worry about it either.  */
9598       if (flag_finite_math_only)
9599         return fold_build2_loc (loc, (max ? MAX_EXPR : MIN_EXPR), type,
9600                             fold_convert_loc (loc, type, arg0),
9601                             fold_convert_loc (loc, type, arg1));
9602     }
9603   return NULL_TREE;
9604 }
9605
9606 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
9607
9608 static tree
9609 fold_builtin_carg (location_t loc, tree arg, tree type)
9610 {
9611   if (validate_arg (arg, COMPLEX_TYPE)
9612       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
9613     {
9614       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
9615
9616       if (atan2_fn)
9617         {
9618           tree new_arg = builtin_save_expr (arg);
9619           tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
9620           tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
9621           return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
9622         }
9623     }
9624
9625   return NULL_TREE;
9626 }
9627
9628 /* Fold a call to builtin logb/ilogb.  */
9629
9630 static tree
9631 fold_builtin_logb (location_t loc, tree arg, tree rettype)
9632 {
9633   if (! validate_arg (arg, REAL_TYPE))
9634     return NULL_TREE;
9635
9636   STRIP_NOPS (arg);
9637
9638   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9639     {
9640       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9641
9642       switch (value->cl)
9643       {
9644       case rvc_nan:
9645       case rvc_inf:
9646         /* If arg is Inf or NaN and we're logb, return it.  */
9647         if (TREE_CODE (rettype) == REAL_TYPE)
9648           return fold_convert_loc (loc, rettype, arg);
9649         /* Fall through... */
9650       case rvc_zero:
9651         /* Zero may set errno and/or raise an exception for logb, also
9652            for ilogb we don't know FP_ILOGB0.  */
9653         return NULL_TREE;
9654       case rvc_normal:
9655         /* For normal numbers, proceed iff radix == 2.  In GCC,
9656            normalized significands are in the range [0.5, 1.0).  We
9657            want the exponent as if they were [1.0, 2.0) so get the
9658            exponent and subtract 1.  */
9659         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9660           return fold_convert_loc (loc, rettype,
9661                                    build_int_cst (integer_type_node,
9662                                                   REAL_EXP (value)-1));
9663         break;
9664       }
9665     }
9666
9667   return NULL_TREE;
9668 }
9669
9670 /* Fold a call to builtin significand, if radix == 2.  */
9671
9672 static tree
9673 fold_builtin_significand (location_t loc, tree arg, tree rettype)
9674 {
9675   if (! validate_arg (arg, REAL_TYPE))
9676     return NULL_TREE;
9677
9678   STRIP_NOPS (arg);
9679
9680   if (TREE_CODE (arg) == REAL_CST && ! TREE_OVERFLOW (arg))
9681     {
9682       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg);
9683
9684       switch (value->cl)
9685       {
9686       case rvc_zero:
9687       case rvc_nan:
9688       case rvc_inf:
9689         /* If arg is +-0, +-Inf or +-NaN, then return it.  */
9690         return fold_convert_loc (loc, rettype, arg);
9691       case rvc_normal:
9692         /* For normal numbers, proceed iff radix == 2.  */
9693         if (REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (arg)))->b == 2)
9694           {
9695             REAL_VALUE_TYPE result = *value;
9696             /* In GCC, normalized significands are in the range [0.5,
9697                1.0).  We want them to be [1.0, 2.0) so set the
9698                exponent to 1.  */
9699             SET_REAL_EXP (&result, 1);
9700             return build_real (rettype, result);
9701           }
9702         break;
9703       }
9704     }
9705
9706   return NULL_TREE;
9707 }
9708
9709 /* Fold a call to builtin frexp, we can assume the base is 2.  */
9710
9711 static tree
9712 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
9713 {
9714   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9715     return NULL_TREE;
9716
9717   STRIP_NOPS (arg0);
9718
9719   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9720     return NULL_TREE;
9721
9722   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9723
9724   /* Proceed if a valid pointer type was passed in.  */
9725   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
9726     {
9727       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9728       tree frac, exp;
9729
9730       switch (value->cl)
9731       {
9732       case rvc_zero:
9733         /* For +-0, return (*exp = 0, +-0).  */
9734         exp = integer_zero_node;
9735         frac = arg0;
9736         break;
9737       case rvc_nan:
9738       case rvc_inf:
9739         /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
9740         return omit_one_operand_loc (loc, rettype, arg0, arg1);
9741       case rvc_normal:
9742         {
9743           /* Since the frexp function always expects base 2, and in
9744              GCC normalized significands are already in the range
9745              [0.5, 1.0), we have exactly what frexp wants.  */
9746           REAL_VALUE_TYPE frac_rvt = *value;
9747           SET_REAL_EXP (&frac_rvt, 0);
9748           frac = build_real (rettype, frac_rvt);
9749           exp = build_int_cst (integer_type_node, REAL_EXP (value));
9750         }
9751         break;
9752       default:
9753         gcc_unreachable ();
9754       }
9755
9756       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9757       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
9758       TREE_SIDE_EFFECTS (arg1) = 1;
9759       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
9760     }
9761
9762   return NULL_TREE;
9763 }
9764
9765 /* Fold a call to builtin ldexp or scalbn/scalbln.  If LDEXP is true
9766    then we can assume the base is two.  If it's false, then we have to
9767    check the mode of the TYPE parameter in certain cases.  */
9768
9769 static tree
9770 fold_builtin_load_exponent (location_t loc, tree arg0, tree arg1,
9771                             tree type, bool ldexp)
9772 {
9773   if (validate_arg (arg0, REAL_TYPE) && validate_arg (arg1, INTEGER_TYPE))
9774     {
9775       STRIP_NOPS (arg0);
9776       STRIP_NOPS (arg1);
9777
9778       /* If arg0 is 0, Inf or NaN, or if arg1 is 0, then return arg0.  */
9779       if (real_zerop (arg0) || integer_zerop (arg1)
9780           || (TREE_CODE (arg0) == REAL_CST
9781               && !real_isfinite (&TREE_REAL_CST (arg0))))
9782         return omit_one_operand_loc (loc, type, arg0, arg1);
9783
9784       /* If both arguments are constant, then try to evaluate it.  */
9785       if ((ldexp || REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2)
9786           && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9787           && host_integerp (arg1, 0))
9788         {
9789           /* Bound the maximum adjustment to twice the range of the
9790              mode's valid exponents.  Use abs to ensure the range is
9791              positive as a sanity check.  */
9792           const long max_exp_adj = 2 *
9793             labs (REAL_MODE_FORMAT (TYPE_MODE (type))->emax
9794                  - REAL_MODE_FORMAT (TYPE_MODE (type))->emin);
9795
9796           /* Get the user-requested adjustment.  */
9797           const HOST_WIDE_INT req_exp_adj = tree_low_cst (arg1, 0);
9798
9799           /* The requested adjustment must be inside this range.  This
9800              is a preliminary cap to avoid things like overflow, we
9801              may still fail to compute the result for other reasons.  */
9802           if (-max_exp_adj < req_exp_adj && req_exp_adj < max_exp_adj)
9803             {
9804               REAL_VALUE_TYPE initial_result;
9805
9806               real_ldexp (&initial_result, &TREE_REAL_CST (arg0), req_exp_adj);
9807
9808               /* Ensure we didn't overflow.  */
9809               if (! real_isinf (&initial_result))
9810                 {
9811                   const REAL_VALUE_TYPE trunc_result
9812                     = real_value_truncate (TYPE_MODE (type), initial_result);
9813
9814                   /* Only proceed if the target mode can hold the
9815                      resulting value.  */
9816                   if (REAL_VALUES_EQUAL (initial_result, trunc_result))
9817                     return build_real (type, trunc_result);
9818                 }
9819             }
9820         }
9821     }
9822
9823   return NULL_TREE;
9824 }
9825
9826 /* Fold a call to builtin modf.  */
9827
9828 static tree
9829 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
9830 {
9831   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
9832     return NULL_TREE;
9833
9834   STRIP_NOPS (arg0);
9835
9836   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
9837     return NULL_TREE;
9838
9839   arg1 = build_fold_indirect_ref_loc (loc, arg1);
9840
9841   /* Proceed if a valid pointer type was passed in.  */
9842   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
9843     {
9844       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
9845       REAL_VALUE_TYPE trunc, frac;
9846
9847       switch (value->cl)
9848       {
9849       case rvc_nan:
9850       case rvc_zero:
9851         /* For +-NaN or +-0, return (*arg1 = arg0, arg0).  */
9852         trunc = frac = *value;
9853         break;
9854       case rvc_inf:
9855         /* For +-Inf, return (*arg1 = arg0, +-0).  */
9856         frac = dconst0;
9857         frac.sign = value->sign;
9858         trunc = *value;
9859         break;
9860       case rvc_normal:
9861         /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)).  */
9862         real_trunc (&trunc, VOIDmode, value);
9863         real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
9864         /* If the original number was negative and already
9865            integral, then the fractional part is -0.0.  */
9866         if (value->sign && frac.cl == rvc_zero)
9867           frac.sign = value->sign;
9868         break;
9869       }
9870
9871       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
9872       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
9873                           build_real (rettype, trunc));
9874       TREE_SIDE_EFFECTS (arg1) = 1;
9875       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
9876                           build_real (rettype, frac));
9877     }
9878
9879   return NULL_TREE;
9880 }
9881
9882 /* Given a location LOC, an interclass builtin function decl FNDECL
9883    and its single argument ARG, return an folded expression computing
9884    the same, or NULL_TREE if we either couldn't or didn't want to fold
9885    (the latter happen if there's an RTL instruction available).  */
9886
9887 static tree
9888 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
9889 {
9890   enum machine_mode mode;
9891
9892   if (!validate_arg (arg, REAL_TYPE))
9893     return NULL_TREE;
9894
9895   if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
9896     return NULL_TREE;
9897
9898   mode = TYPE_MODE (TREE_TYPE (arg));
9899
9900   /* If there is no optab, try generic code.  */
9901   switch (DECL_FUNCTION_CODE (fndecl))
9902     {
9903       tree result;
9904
9905     CASE_FLT_FN (BUILT_IN_ISINF):
9906       {
9907         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
9908         tree const isgr_fn = builtin_decl_explicit (BUILT_IN_ISGREATER);
9909         tree const type = TREE_TYPE (arg);
9910         REAL_VALUE_TYPE r;
9911         char buf[128];
9912
9913         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9914         real_from_string (&r, buf);
9915         result = build_call_expr (isgr_fn, 2,
9916                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9917                                   build_real (type, r));
9918         return result;
9919       }
9920     CASE_FLT_FN (BUILT_IN_FINITE):
9921     case BUILT_IN_ISFINITE:
9922       {
9923         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
9924         tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
9925         tree const type = TREE_TYPE (arg);
9926         REAL_VALUE_TYPE r;
9927         char buf[128];
9928
9929         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9930         real_from_string (&r, buf);
9931         result = build_call_expr (isle_fn, 2,
9932                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9933                                   build_real (type, r));
9934         /*result = fold_build2_loc (loc, UNGT_EXPR,
9935                                   TREE_TYPE (TREE_TYPE (fndecl)),
9936                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
9937                                   build_real (type, r));
9938         result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
9939                                   TREE_TYPE (TREE_TYPE (fndecl)),
9940                                   result);*/
9941         return result;
9942       }
9943     case BUILT_IN_ISNORMAL:
9944       {
9945         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
9946            islessequal(fabs(x),DBL_MAX).  */
9947         tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
9948         tree const isge_fn = builtin_decl_explicit (BUILT_IN_ISGREATEREQUAL);
9949         tree const type = TREE_TYPE (arg);
9950         REAL_VALUE_TYPE rmax, rmin;
9951         char buf[128];
9952
9953         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
9954         real_from_string (&rmax, buf);
9955         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
9956         real_from_string (&rmin, buf);
9957         arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
9958         result = build_call_expr (isle_fn, 2, arg,
9959                                   build_real (type, rmax));
9960         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
9961                               build_call_expr (isge_fn, 2, arg,
9962                                                build_real (type, rmin)));
9963         return result;
9964       }
9965     default:
9966       break;
9967     }
9968
9969   return NULL_TREE;
9970 }
9971
9972 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
9973    ARG is the argument for the call.  */
9974
9975 static tree
9976 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
9977 {
9978   tree type = TREE_TYPE (TREE_TYPE (fndecl));
9979   REAL_VALUE_TYPE r;
9980
9981   if (!validate_arg (arg, REAL_TYPE))
9982     return NULL_TREE;
9983
9984   switch (builtin_index)
9985     {
9986     case BUILT_IN_ISINF:
9987       if (!HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
9988         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
9989
9990       if (TREE_CODE (arg) == REAL_CST)
9991         {
9992           r = TREE_REAL_CST (arg);
9993           if (real_isinf (&r))
9994             return real_compare (GT_EXPR, &r, &dconst0)
9995                    ? integer_one_node : integer_minus_one_node;
9996           else
9997             return integer_zero_node;
9998         }
9999
10000       return NULL_TREE;
10001
10002     case BUILT_IN_ISINF_SIGN:
10003       {
10004         /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
10005         /* In a boolean context, GCC will fold the inner COND_EXPR to
10006            1.  So e.g. "if (isinf_sign(x))" would be folded to just
10007            "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
10008         tree signbit_fn = mathfn_built_in_1 (TREE_TYPE (arg), BUILT_IN_SIGNBIT, 0);
10009         tree isinf_fn = builtin_decl_explicit (BUILT_IN_ISINF);
10010         tree tmp = NULL_TREE;
10011
10012         arg = builtin_save_expr (arg);
10013
10014         if (signbit_fn && isinf_fn)
10015           {
10016             tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
10017             tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
10018
10019             signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
10020                                         signbit_call, integer_zero_node);
10021             isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
10022                                       isinf_call, integer_zero_node);
10023
10024             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
10025                                integer_minus_one_node, integer_one_node);
10026             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
10027                                isinf_call, tmp,
10028                                integer_zero_node);
10029           }
10030
10031         return tmp;
10032       }
10033
10034     case BUILT_IN_ISFINITE:
10035       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg)))
10036           && !HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (arg))))
10037         return omit_one_operand_loc (loc, type, integer_one_node, arg);
10038
10039       if (TREE_CODE (arg) == REAL_CST)
10040         {
10041           r = TREE_REAL_CST (arg);
10042           return real_isfinite (&r) ? integer_one_node : integer_zero_node;
10043         }
10044
10045       return NULL_TREE;
10046
10047     case BUILT_IN_ISNAN:
10048       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg))))
10049         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
10050
10051       if (TREE_CODE (arg) == REAL_CST)
10052         {
10053           r = TREE_REAL_CST (arg);
10054           return real_isnan (&r) ? integer_one_node : integer_zero_node;
10055         }
10056
10057       arg = builtin_save_expr (arg);
10058       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
10059
10060     default:
10061       gcc_unreachable ();
10062     }
10063 }
10064
10065 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
10066    This builtin will generate code to return the appropriate floating
10067    point classification depending on the value of the floating point
10068    number passed in.  The possible return values must be supplied as
10069    int arguments to the call in the following order: FP_NAN, FP_INFINITE,
10070    FP_NORMAL, FP_SUBNORMAL and FP_ZERO.  The ellipses is for exactly
10071    one floating point argument which is "type generic".  */
10072
10073 static tree
10074 fold_builtin_fpclassify (location_t loc, tree exp)
10075 {
10076   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
10077     arg, type, res, tmp;
10078   enum machine_mode mode;
10079   REAL_VALUE_TYPE r;
10080   char buf[128];
10081
10082   /* Verify the required arguments in the original call.  */
10083   if (!validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE,
10084                          INTEGER_TYPE, INTEGER_TYPE,
10085                          INTEGER_TYPE, REAL_TYPE, VOID_TYPE))
10086     return NULL_TREE;
10087
10088   fp_nan = CALL_EXPR_ARG (exp, 0);
10089   fp_infinite = CALL_EXPR_ARG (exp, 1);
10090   fp_normal = CALL_EXPR_ARG (exp, 2);
10091   fp_subnormal = CALL_EXPR_ARG (exp, 3);
10092   fp_zero = CALL_EXPR_ARG (exp, 4);
10093   arg = CALL_EXPR_ARG (exp, 5);
10094   type = TREE_TYPE (arg);
10095   mode = TYPE_MODE (type);
10096   arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
10097
10098   /* fpclassify(x) ->
10099        isnan(x) ? FP_NAN :
10100          (fabs(x) == Inf ? FP_INFINITE :
10101            (fabs(x) >= DBL_MIN ? FP_NORMAL :
10102              (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
10103
10104   tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
10105                      build_real (type, dconst0));
10106   res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
10107                      tmp, fp_zero, fp_subnormal);
10108
10109   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
10110   real_from_string (&r, buf);
10111   tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
10112                      arg, build_real (type, r));
10113   res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
10114
10115   if (HONOR_INFINITIES (mode))
10116     {
10117       real_inf (&r);
10118       tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
10119                          build_real (type, r));
10120       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
10121                          fp_infinite, res);
10122     }
10123
10124   if (HONOR_NANS (mode))
10125     {
10126       tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
10127       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
10128     }
10129
10130   return res;
10131 }
10132
10133 /* Fold a call to an unordered comparison function such as
10134    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
10135    being called and ARG0 and ARG1 are the arguments for the call.
10136    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
10137    the opposite of the desired result.  UNORDERED_CODE is used
10138    for modes that can hold NaNs and ORDERED_CODE is used for
10139    the rest.  */
10140
10141 static tree
10142 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
10143                             enum tree_code unordered_code,
10144                             enum tree_code ordered_code)
10145 {
10146   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10147   enum tree_code code;
10148   tree type0, type1;
10149   enum tree_code code0, code1;
10150   tree cmp_type = NULL_TREE;
10151
10152   type0 = TREE_TYPE (arg0);
10153   type1 = TREE_TYPE (arg1);
10154
10155   code0 = TREE_CODE (type0);
10156   code1 = TREE_CODE (type1);
10157
10158   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
10159     /* Choose the wider of two real types.  */
10160     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
10161       ? type0 : type1;
10162   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
10163     cmp_type = type0;
10164   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
10165     cmp_type = type1;
10166
10167   arg0 = fold_convert_loc (loc, cmp_type, arg0);
10168   arg1 = fold_convert_loc (loc, cmp_type, arg1);
10169
10170   if (unordered_code == UNORDERED_EXPR)
10171     {
10172       if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
10173         return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
10174       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
10175     }
10176
10177   code = HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))) ? unordered_code
10178                                                    : ordered_code;
10179   return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
10180                       fold_build2_loc (loc, code, type, arg0, arg1));
10181 }
10182
10183 /* Fold a call to built-in function FNDECL with 0 arguments.
10184    IGNORE is true if the result of the function call is ignored.  This
10185    function returns NULL_TREE if no simplification was possible.  */
10186
10187 static tree
10188 fold_builtin_0 (location_t loc, tree fndecl, bool ignore ATTRIBUTE_UNUSED)
10189 {
10190   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10191   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10192   switch (fcode)
10193     {
10194     CASE_FLT_FN (BUILT_IN_INF):
10195     case BUILT_IN_INFD32:
10196     case BUILT_IN_INFD64:
10197     case BUILT_IN_INFD128:
10198       return fold_builtin_inf (loc, type, true);
10199
10200     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
10201       return fold_builtin_inf (loc, type, false);
10202
10203     case BUILT_IN_CLASSIFY_TYPE:
10204       return fold_builtin_classify_type (NULL_TREE);
10205
10206     default:
10207       break;
10208     }
10209   return NULL_TREE;
10210 }
10211
10212 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
10213    IGNORE is true if the result of the function call is ignored.  This
10214    function returns NULL_TREE if no simplification was possible.  */
10215
10216 static tree
10217 fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
10218 {
10219   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10220   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10221   switch (fcode)
10222     {
10223     case BUILT_IN_CONSTANT_P:
10224       {
10225         tree val = fold_builtin_constant_p (arg0);
10226
10227         /* Gimplification will pull the CALL_EXPR for the builtin out of
10228            an if condition.  When not optimizing, we'll not CSE it back.
10229            To avoid link error types of regressions, return false now.  */
10230         if (!val && !optimize)
10231           val = integer_zero_node;
10232
10233         return val;
10234       }
10235
10236     case BUILT_IN_CLASSIFY_TYPE:
10237       return fold_builtin_classify_type (arg0);
10238
10239     case BUILT_IN_STRLEN:
10240       return fold_builtin_strlen (loc, type, arg0);
10241
10242     CASE_FLT_FN (BUILT_IN_FABS):
10243       return fold_builtin_fabs (loc, arg0, type);
10244
10245     case BUILT_IN_ABS:
10246     case BUILT_IN_LABS:
10247     case BUILT_IN_LLABS:
10248     case BUILT_IN_IMAXABS:
10249       return fold_builtin_abs (loc, arg0, type);
10250
10251     CASE_FLT_FN (BUILT_IN_CONJ):
10252       if (validate_arg (arg0, COMPLEX_TYPE)
10253         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10254         return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
10255     break;
10256
10257     CASE_FLT_FN (BUILT_IN_CREAL):
10258       if (validate_arg (arg0, COMPLEX_TYPE)
10259         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10260         return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));;
10261     break;
10262
10263     CASE_FLT_FN (BUILT_IN_CIMAG):
10264       if (validate_arg (arg0, COMPLEX_TYPE)
10265           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10266         return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
10267     break;
10268
10269     CASE_FLT_FN (BUILT_IN_CCOS):
10270       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
10271
10272     CASE_FLT_FN (BUILT_IN_CCOSH):
10273       return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
10274
10275     CASE_FLT_FN (BUILT_IN_CPROJ):
10276       return fold_builtin_cproj(loc, arg0, type);
10277
10278     CASE_FLT_FN (BUILT_IN_CSIN):
10279       if (validate_arg (arg0, COMPLEX_TYPE)
10280           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10281         return do_mpc_arg1 (arg0, type, mpc_sin);
10282     break;
10283
10284     CASE_FLT_FN (BUILT_IN_CSINH):
10285       if (validate_arg (arg0, COMPLEX_TYPE)
10286           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10287         return do_mpc_arg1 (arg0, type, mpc_sinh);
10288     break;
10289
10290     CASE_FLT_FN (BUILT_IN_CTAN):
10291       if (validate_arg (arg0, COMPLEX_TYPE)
10292           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10293         return do_mpc_arg1 (arg0, type, mpc_tan);
10294     break;
10295
10296     CASE_FLT_FN (BUILT_IN_CTANH):
10297       if (validate_arg (arg0, COMPLEX_TYPE)
10298           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10299         return do_mpc_arg1 (arg0, type, mpc_tanh);
10300     break;
10301
10302     CASE_FLT_FN (BUILT_IN_CLOG):
10303       if (validate_arg (arg0, COMPLEX_TYPE)
10304           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10305         return do_mpc_arg1 (arg0, type, mpc_log);
10306     break;
10307
10308     CASE_FLT_FN (BUILT_IN_CSQRT):
10309       if (validate_arg (arg0, COMPLEX_TYPE)
10310           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10311         return do_mpc_arg1 (arg0, type, mpc_sqrt);
10312     break;
10313
10314     CASE_FLT_FN (BUILT_IN_CASIN):
10315       if (validate_arg (arg0, COMPLEX_TYPE)
10316           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10317         return do_mpc_arg1 (arg0, type, mpc_asin);
10318     break;
10319
10320     CASE_FLT_FN (BUILT_IN_CACOS):
10321       if (validate_arg (arg0, COMPLEX_TYPE)
10322           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10323         return do_mpc_arg1 (arg0, type, mpc_acos);
10324     break;
10325
10326     CASE_FLT_FN (BUILT_IN_CATAN):
10327       if (validate_arg (arg0, COMPLEX_TYPE)
10328           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10329         return do_mpc_arg1 (arg0, type, mpc_atan);
10330     break;
10331
10332     CASE_FLT_FN (BUILT_IN_CASINH):
10333       if (validate_arg (arg0, COMPLEX_TYPE)
10334           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10335         return do_mpc_arg1 (arg0, type, mpc_asinh);
10336     break;
10337
10338     CASE_FLT_FN (BUILT_IN_CACOSH):
10339       if (validate_arg (arg0, COMPLEX_TYPE)
10340           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10341         return do_mpc_arg1 (arg0, type, mpc_acosh);
10342     break;
10343
10344     CASE_FLT_FN (BUILT_IN_CATANH):
10345       if (validate_arg (arg0, COMPLEX_TYPE)
10346           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
10347         return do_mpc_arg1 (arg0, type, mpc_atanh);
10348     break;
10349
10350     CASE_FLT_FN (BUILT_IN_CABS):
10351       return fold_builtin_cabs (loc, arg0, type, fndecl);
10352
10353     CASE_FLT_FN (BUILT_IN_CARG):
10354       return fold_builtin_carg (loc, arg0, type);
10355
10356     CASE_FLT_FN (BUILT_IN_SQRT):
10357       return fold_builtin_sqrt (loc, arg0, type);
10358
10359     CASE_FLT_FN (BUILT_IN_CBRT):
10360       return fold_builtin_cbrt (loc, arg0, type);
10361
10362     CASE_FLT_FN (BUILT_IN_ASIN):
10363       if (validate_arg (arg0, REAL_TYPE))
10364         return do_mpfr_arg1 (arg0, type, mpfr_asin,
10365                              &dconstm1, &dconst1, true);
10366     break;
10367
10368     CASE_FLT_FN (BUILT_IN_ACOS):
10369       if (validate_arg (arg0, REAL_TYPE))
10370         return do_mpfr_arg1 (arg0, type, mpfr_acos,
10371                              &dconstm1, &dconst1, true);
10372     break;
10373
10374     CASE_FLT_FN (BUILT_IN_ATAN):
10375       if (validate_arg (arg0, REAL_TYPE))
10376         return do_mpfr_arg1 (arg0, type, mpfr_atan, NULL, NULL, 0);
10377     break;
10378
10379     CASE_FLT_FN (BUILT_IN_ASINH):
10380       if (validate_arg (arg0, REAL_TYPE))
10381         return do_mpfr_arg1 (arg0, type, mpfr_asinh, NULL, NULL, 0);
10382     break;
10383
10384     CASE_FLT_FN (BUILT_IN_ACOSH):
10385       if (validate_arg (arg0, REAL_TYPE))
10386         return do_mpfr_arg1 (arg0, type, mpfr_acosh,
10387                              &dconst1, NULL, true);
10388     break;
10389
10390     CASE_FLT_FN (BUILT_IN_ATANH):
10391       if (validate_arg (arg0, REAL_TYPE))
10392         return do_mpfr_arg1 (arg0, type, mpfr_atanh,
10393                              &dconstm1, &dconst1, false);
10394     break;
10395
10396     CASE_FLT_FN (BUILT_IN_SIN):
10397       if (validate_arg (arg0, REAL_TYPE))
10398         return do_mpfr_arg1 (arg0, type, mpfr_sin, NULL, NULL, 0);
10399     break;
10400
10401     CASE_FLT_FN (BUILT_IN_COS):
10402       return fold_builtin_cos (loc, arg0, type, fndecl);
10403
10404     CASE_FLT_FN (BUILT_IN_TAN):
10405       return fold_builtin_tan (arg0, type);
10406
10407     CASE_FLT_FN (BUILT_IN_CEXP):
10408       return fold_builtin_cexp (loc, arg0, type);
10409
10410     CASE_FLT_FN (BUILT_IN_CEXPI):
10411       if (validate_arg (arg0, REAL_TYPE))
10412         return do_mpfr_sincos (arg0, NULL_TREE, NULL_TREE);
10413     break;
10414
10415     CASE_FLT_FN (BUILT_IN_SINH):
10416       if (validate_arg (arg0, REAL_TYPE))
10417         return do_mpfr_arg1 (arg0, type, mpfr_sinh, NULL, NULL, 0);
10418     break;
10419
10420     CASE_FLT_FN (BUILT_IN_COSH):
10421       return fold_builtin_cosh (loc, arg0, type, fndecl);
10422
10423     CASE_FLT_FN (BUILT_IN_TANH):
10424       if (validate_arg (arg0, REAL_TYPE))
10425         return do_mpfr_arg1 (arg0, type, mpfr_tanh, NULL, NULL, 0);
10426     break;
10427
10428     CASE_FLT_FN (BUILT_IN_ERF):
10429       if (validate_arg (arg0, REAL_TYPE))
10430         return do_mpfr_arg1 (arg0, type, mpfr_erf, NULL, NULL, 0);
10431     break;
10432
10433     CASE_FLT_FN (BUILT_IN_ERFC):
10434       if (validate_arg (arg0, REAL_TYPE))
10435         return do_mpfr_arg1 (arg0, type, mpfr_erfc, NULL, NULL, 0);
10436     break;
10437
10438     CASE_FLT_FN (BUILT_IN_TGAMMA):
10439       if (validate_arg (arg0, REAL_TYPE))
10440         return do_mpfr_arg1 (arg0, type, mpfr_gamma, NULL, NULL, 0);
10441     break;
10442
10443     CASE_FLT_FN (BUILT_IN_EXP):
10444       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp);
10445
10446     CASE_FLT_FN (BUILT_IN_EXP2):
10447       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp2);
10448
10449     CASE_FLT_FN (BUILT_IN_EXP10):
10450     CASE_FLT_FN (BUILT_IN_POW10):
10451       return fold_builtin_exponent (loc, fndecl, arg0, mpfr_exp10);
10452
10453     CASE_FLT_FN (BUILT_IN_EXPM1):
10454       if (validate_arg (arg0, REAL_TYPE))
10455         return do_mpfr_arg1 (arg0, type, mpfr_expm1, NULL, NULL, 0);
10456     break;
10457
10458     CASE_FLT_FN (BUILT_IN_LOG):
10459     return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log);
10460
10461     CASE_FLT_FN (BUILT_IN_LOG2):
10462       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log2);
10463
10464     CASE_FLT_FN (BUILT_IN_LOG10):
10465       return fold_builtin_logarithm (loc, fndecl, arg0, mpfr_log10);
10466
10467     CASE_FLT_FN (BUILT_IN_LOG1P):
10468       if (validate_arg (arg0, REAL_TYPE))
10469         return do_mpfr_arg1 (arg0, type, mpfr_log1p,
10470                              &dconstm1, NULL, false);
10471     break;
10472
10473     CASE_FLT_FN (BUILT_IN_J0):
10474       if (validate_arg (arg0, REAL_TYPE))
10475         return do_mpfr_arg1 (arg0, type, mpfr_j0,
10476                              NULL, NULL, 0);
10477     break;
10478
10479     CASE_FLT_FN (BUILT_IN_J1):
10480       if (validate_arg (arg0, REAL_TYPE))
10481         return do_mpfr_arg1 (arg0, type, mpfr_j1,
10482                              NULL, NULL, 0);
10483     break;
10484
10485     CASE_FLT_FN (BUILT_IN_Y0):
10486       if (validate_arg (arg0, REAL_TYPE))
10487         return do_mpfr_arg1 (arg0, type, mpfr_y0,
10488                              &dconst0, NULL, false);
10489     break;
10490
10491     CASE_FLT_FN (BUILT_IN_Y1):
10492       if (validate_arg (arg0, REAL_TYPE))
10493         return do_mpfr_arg1 (arg0, type, mpfr_y1,
10494                              &dconst0, NULL, false);
10495     break;
10496
10497     CASE_FLT_FN (BUILT_IN_NAN):
10498     case BUILT_IN_NAND32:
10499     case BUILT_IN_NAND64:
10500     case BUILT_IN_NAND128:
10501       return fold_builtin_nan (arg0, type, true);
10502
10503     CASE_FLT_FN (BUILT_IN_NANS):
10504       return fold_builtin_nan (arg0, type, false);
10505
10506     CASE_FLT_FN (BUILT_IN_FLOOR):
10507       return fold_builtin_floor (loc, fndecl, arg0);
10508
10509     CASE_FLT_FN (BUILT_IN_CEIL):
10510       return fold_builtin_ceil (loc, fndecl, arg0);
10511
10512     CASE_FLT_FN (BUILT_IN_TRUNC):
10513       return fold_builtin_trunc (loc, fndecl, arg0);
10514
10515     CASE_FLT_FN (BUILT_IN_ROUND):
10516       return fold_builtin_round (loc, fndecl, arg0);
10517
10518     CASE_FLT_FN (BUILT_IN_NEARBYINT):
10519     CASE_FLT_FN (BUILT_IN_RINT):
10520       return fold_trunc_transparent_mathfn (loc, fndecl, arg0);
10521
10522     CASE_FLT_FN (BUILT_IN_ICEIL):
10523     CASE_FLT_FN (BUILT_IN_LCEIL):
10524     CASE_FLT_FN (BUILT_IN_LLCEIL):
10525     CASE_FLT_FN (BUILT_IN_LFLOOR):
10526     CASE_FLT_FN (BUILT_IN_IFLOOR):
10527     CASE_FLT_FN (BUILT_IN_LLFLOOR):
10528     CASE_FLT_FN (BUILT_IN_IROUND):
10529     CASE_FLT_FN (BUILT_IN_LROUND):
10530     CASE_FLT_FN (BUILT_IN_LLROUND):
10531       return fold_builtin_int_roundingfn (loc, fndecl, arg0);
10532
10533     CASE_FLT_FN (BUILT_IN_IRINT):
10534     CASE_FLT_FN (BUILT_IN_LRINT):
10535     CASE_FLT_FN (BUILT_IN_LLRINT):
10536       return fold_fixed_mathfn (loc, fndecl, arg0);
10537
10538     case BUILT_IN_BSWAP16:
10539     case BUILT_IN_BSWAP32:
10540     case BUILT_IN_BSWAP64:
10541       return fold_builtin_bswap (fndecl, arg0);
10542
10543     CASE_INT_FN (BUILT_IN_FFS):
10544     CASE_INT_FN (BUILT_IN_CLZ):
10545     CASE_INT_FN (BUILT_IN_CTZ):
10546     CASE_INT_FN (BUILT_IN_CLRSB):
10547     CASE_INT_FN (BUILT_IN_POPCOUNT):
10548     CASE_INT_FN (BUILT_IN_PARITY):
10549       return fold_builtin_bitop (fndecl, arg0);
10550
10551     CASE_FLT_FN (BUILT_IN_SIGNBIT):
10552       return fold_builtin_signbit (loc, arg0, type);
10553
10554     CASE_FLT_FN (BUILT_IN_SIGNIFICAND):
10555       return fold_builtin_significand (loc, arg0, type);
10556
10557     CASE_FLT_FN (BUILT_IN_ILOGB):
10558     CASE_FLT_FN (BUILT_IN_LOGB):
10559       return fold_builtin_logb (loc, arg0, type);
10560
10561     case BUILT_IN_ISASCII:
10562       return fold_builtin_isascii (loc, arg0);
10563
10564     case BUILT_IN_TOASCII:
10565       return fold_builtin_toascii (loc, arg0);
10566
10567     case BUILT_IN_ISDIGIT:
10568       return fold_builtin_isdigit (loc, arg0);
10569
10570     CASE_FLT_FN (BUILT_IN_FINITE):
10571     case BUILT_IN_FINITED32:
10572     case BUILT_IN_FINITED64:
10573     case BUILT_IN_FINITED128:
10574     case BUILT_IN_ISFINITE:
10575       {
10576         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
10577         if (ret)
10578           return ret;
10579         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10580       }
10581
10582     CASE_FLT_FN (BUILT_IN_ISINF):
10583     case BUILT_IN_ISINFD32:
10584     case BUILT_IN_ISINFD64:
10585     case BUILT_IN_ISINFD128:
10586       {
10587         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
10588         if (ret)
10589           return ret;
10590         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10591       }
10592
10593     case BUILT_IN_ISNORMAL:
10594       return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
10595
10596     case BUILT_IN_ISINF_SIGN:
10597       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
10598
10599     CASE_FLT_FN (BUILT_IN_ISNAN):
10600     case BUILT_IN_ISNAND32:
10601     case BUILT_IN_ISNAND64:
10602     case BUILT_IN_ISNAND128:
10603       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
10604
10605     case BUILT_IN_PRINTF:
10606     case BUILT_IN_PRINTF_UNLOCKED:
10607     case BUILT_IN_VPRINTF:
10608       return fold_builtin_printf (loc, fndecl, arg0, NULL_TREE, ignore, fcode);
10609
10610     case BUILT_IN_FREE:
10611       if (integer_zerop (arg0))
10612         return build_empty_stmt (loc);
10613       break;
10614
10615     default:
10616       break;
10617     }
10618
10619   return NULL_TREE;
10620
10621 }
10622
10623 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
10624    IGNORE is true if the result of the function call is ignored.  This
10625    function returns NULL_TREE if no simplification was possible.  */
10626
10627 static tree
10628 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore)
10629 {
10630   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10631   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10632
10633   switch (fcode)
10634     {
10635     CASE_FLT_FN (BUILT_IN_JN):
10636       if (validate_arg (arg0, INTEGER_TYPE)
10637           && validate_arg (arg1, REAL_TYPE))
10638         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_jn, NULL, 0);
10639     break;
10640
10641     CASE_FLT_FN (BUILT_IN_YN):
10642       if (validate_arg (arg0, INTEGER_TYPE)
10643           && validate_arg (arg1, REAL_TYPE))
10644         return do_mpfr_bessel_n (arg0, arg1, type, mpfr_yn,
10645                                  &dconst0, false);
10646     break;
10647
10648     CASE_FLT_FN (BUILT_IN_DREM):
10649     CASE_FLT_FN (BUILT_IN_REMAINDER):
10650       if (validate_arg (arg0, REAL_TYPE)
10651           && validate_arg(arg1, REAL_TYPE))
10652         return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
10653     break;
10654
10655     CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
10656     CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
10657       if (validate_arg (arg0, REAL_TYPE)
10658           && validate_arg(arg1, POINTER_TYPE))
10659         return do_mpfr_lgamma_r (arg0, arg1, type);
10660     break;
10661
10662     CASE_FLT_FN (BUILT_IN_ATAN2):
10663       if (validate_arg (arg0, REAL_TYPE)
10664           && validate_arg(arg1, REAL_TYPE))
10665         return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
10666     break;
10667
10668     CASE_FLT_FN (BUILT_IN_FDIM):
10669       if (validate_arg (arg0, REAL_TYPE)
10670           && validate_arg(arg1, REAL_TYPE))
10671         return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
10672     break;
10673
10674     CASE_FLT_FN (BUILT_IN_HYPOT):
10675       return fold_builtin_hypot (loc, fndecl, arg0, arg1, type);
10676
10677     CASE_FLT_FN (BUILT_IN_CPOW):
10678       if (validate_arg (arg0, COMPLEX_TYPE)
10679           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
10680           && validate_arg (arg1, COMPLEX_TYPE)
10681           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE)
10682         return do_mpc_arg2 (arg0, arg1, type, /*do_nonfinite=*/ 0, mpc_pow);
10683     break;
10684
10685     CASE_FLT_FN (BUILT_IN_LDEXP):
10686       return fold_builtin_load_exponent (loc, arg0, arg1, type, /*ldexp=*/true);
10687     CASE_FLT_FN (BUILT_IN_SCALBN):
10688     CASE_FLT_FN (BUILT_IN_SCALBLN):
10689       return fold_builtin_load_exponent (loc, arg0, arg1,
10690                                          type, /*ldexp=*/false);
10691
10692     CASE_FLT_FN (BUILT_IN_FREXP):
10693       return fold_builtin_frexp (loc, arg0, arg1, type);
10694
10695     CASE_FLT_FN (BUILT_IN_MODF):
10696       return fold_builtin_modf (loc, arg0, arg1, type);
10697
10698     case BUILT_IN_BZERO:
10699       return fold_builtin_bzero (loc, arg0, arg1, ignore);
10700
10701     case BUILT_IN_FPUTS:
10702       return fold_builtin_fputs (loc, arg0, arg1, ignore, false, NULL_TREE);
10703
10704     case BUILT_IN_FPUTS_UNLOCKED:
10705       return fold_builtin_fputs (loc, arg0, arg1, ignore, true, NULL_TREE);
10706
10707     case BUILT_IN_STRSTR:
10708       return fold_builtin_strstr (loc, arg0, arg1, type);
10709
10710     case BUILT_IN_STRCAT:
10711       return fold_builtin_strcat (loc, arg0, arg1);
10712
10713     case BUILT_IN_STRSPN:
10714       return fold_builtin_strspn (loc, arg0, arg1);
10715
10716     case BUILT_IN_STRCSPN:
10717       return fold_builtin_strcspn (loc, arg0, arg1);
10718
10719     case BUILT_IN_STRCHR:
10720     case BUILT_IN_INDEX:
10721       return fold_builtin_strchr (loc, arg0, arg1, type);
10722
10723     case BUILT_IN_STRRCHR:
10724     case BUILT_IN_RINDEX:
10725       return fold_builtin_strrchr (loc, arg0, arg1, type);
10726
10727     case BUILT_IN_STRCPY:
10728       return fold_builtin_strcpy (loc, fndecl, arg0, arg1, NULL_TREE);
10729
10730     case BUILT_IN_STPCPY:
10731       if (ignore)
10732         {
10733           tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
10734           if (!fn)
10735             break;
10736
10737           return build_call_expr_loc (loc, fn, 2, arg0, arg1);
10738         }
10739       else
10740         return fold_builtin_stpcpy (loc, fndecl, arg0, arg1);
10741       break;
10742
10743     case BUILT_IN_STRCMP:
10744       return fold_builtin_strcmp (loc, arg0, arg1);
10745
10746     case BUILT_IN_STRPBRK:
10747       return fold_builtin_strpbrk (loc, arg0, arg1, type);
10748
10749     case BUILT_IN_EXPECT:
10750       return fold_builtin_expect (loc, arg0, arg1);
10751
10752     CASE_FLT_FN (BUILT_IN_POW):
10753       return fold_builtin_pow (loc, fndecl, arg0, arg1, type);
10754
10755     CASE_FLT_FN (BUILT_IN_POWI):
10756       return fold_builtin_powi (loc, fndecl, arg0, arg1, type);
10757
10758     CASE_FLT_FN (BUILT_IN_COPYSIGN):
10759       return fold_builtin_copysign (loc, fndecl, arg0, arg1, type);
10760
10761     CASE_FLT_FN (BUILT_IN_FMIN):
10762       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/false);
10763
10764     CASE_FLT_FN (BUILT_IN_FMAX):
10765       return fold_builtin_fmin_fmax (loc, arg0, arg1, type, /*max=*/true);
10766
10767     case BUILT_IN_ISGREATER:
10768       return fold_builtin_unordered_cmp (loc, fndecl,
10769                                          arg0, arg1, UNLE_EXPR, LE_EXPR);
10770     case BUILT_IN_ISGREATEREQUAL:
10771       return fold_builtin_unordered_cmp (loc, fndecl,
10772                                          arg0, arg1, UNLT_EXPR, LT_EXPR);
10773     case BUILT_IN_ISLESS:
10774       return fold_builtin_unordered_cmp (loc, fndecl,
10775                                          arg0, arg1, UNGE_EXPR, GE_EXPR);
10776     case BUILT_IN_ISLESSEQUAL:
10777       return fold_builtin_unordered_cmp (loc, fndecl,
10778                                          arg0, arg1, UNGT_EXPR, GT_EXPR);
10779     case BUILT_IN_ISLESSGREATER:
10780       return fold_builtin_unordered_cmp (loc, fndecl,
10781                                          arg0, arg1, UNEQ_EXPR, EQ_EXPR);
10782     case BUILT_IN_ISUNORDERED:
10783       return fold_builtin_unordered_cmp (loc, fndecl,
10784                                          arg0, arg1, UNORDERED_EXPR,
10785                                          NOP_EXPR);
10786
10787       /* We do the folding for va_start in the expander.  */
10788     case BUILT_IN_VA_START:
10789       break;
10790
10791     case BUILT_IN_SPRINTF:
10792       return fold_builtin_sprintf (loc, arg0, arg1, NULL_TREE, ignore);
10793
10794     case BUILT_IN_OBJECT_SIZE:
10795       return fold_builtin_object_size (arg0, arg1);
10796
10797     case BUILT_IN_PRINTF:
10798     case BUILT_IN_PRINTF_UNLOCKED:
10799     case BUILT_IN_VPRINTF:
10800       return fold_builtin_printf (loc, fndecl, arg0, arg1, ignore, fcode);
10801
10802     case BUILT_IN_PRINTF_CHK:
10803     case BUILT_IN_VPRINTF_CHK:
10804       if (!validate_arg (arg0, INTEGER_TYPE)
10805           || TREE_SIDE_EFFECTS (arg0))
10806         return NULL_TREE;
10807       else
10808         return fold_builtin_printf (loc, fndecl,
10809                                     arg1, NULL_TREE, ignore, fcode);
10810     break;
10811
10812     case BUILT_IN_FPRINTF:
10813     case BUILT_IN_FPRINTF_UNLOCKED:
10814     case BUILT_IN_VFPRINTF:
10815       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, NULL_TREE,
10816                                    ignore, fcode);
10817
10818     case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
10819       return fold_builtin_atomic_always_lock_free (arg0, arg1);
10820
10821     case BUILT_IN_ATOMIC_IS_LOCK_FREE:
10822       return fold_builtin_atomic_is_lock_free (arg0, arg1);
10823
10824     default:
10825       break;
10826     }
10827   return NULL_TREE;
10828 }
10829
10830 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
10831    and ARG2.  IGNORE is true if the result of the function call is ignored.
10832    This function returns NULL_TREE if no simplification was possible.  */
10833
10834 static tree
10835 fold_builtin_3 (location_t loc, tree fndecl,
10836                 tree arg0, tree arg1, tree arg2, bool ignore)
10837 {
10838   tree type = TREE_TYPE (TREE_TYPE (fndecl));
10839   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10840   switch (fcode)
10841     {
10842
10843     CASE_FLT_FN (BUILT_IN_SINCOS):
10844       return fold_builtin_sincos (loc, arg0, arg1, arg2);
10845
10846     CASE_FLT_FN (BUILT_IN_FMA):
10847       return fold_builtin_fma (loc, arg0, arg1, arg2, type);
10848     break;
10849
10850     CASE_FLT_FN (BUILT_IN_REMQUO):
10851       if (validate_arg (arg0, REAL_TYPE)
10852           && validate_arg(arg1, REAL_TYPE)
10853           && validate_arg(arg2, POINTER_TYPE))
10854         return do_mpfr_remquo (arg0, arg1, arg2);
10855     break;
10856
10857     case BUILT_IN_MEMSET:
10858       return fold_builtin_memset (loc, arg0, arg1, arg2, type, ignore);
10859
10860     case BUILT_IN_BCOPY:
10861       return fold_builtin_memory_op (loc, arg1, arg0, arg2,
10862                                      void_type_node, true, /*endp=*/3);
10863
10864     case BUILT_IN_MEMCPY:
10865       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10866                                      type, ignore, /*endp=*/0);
10867
10868     case BUILT_IN_MEMPCPY:
10869       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10870                                      type, ignore, /*endp=*/1);
10871
10872     case BUILT_IN_MEMMOVE:
10873       return fold_builtin_memory_op (loc, arg0, arg1, arg2,
10874                                      type, ignore, /*endp=*/3);
10875
10876     case BUILT_IN_STRNCAT:
10877       return fold_builtin_strncat (loc, arg0, arg1, arg2);
10878
10879     case BUILT_IN_STRNCPY:
10880       return fold_builtin_strncpy (loc, fndecl, arg0, arg1, arg2, NULL_TREE);
10881
10882     case BUILT_IN_STRNCMP:
10883       return fold_builtin_strncmp (loc, arg0, arg1, arg2);
10884
10885     case BUILT_IN_MEMCHR:
10886       return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
10887
10888     case BUILT_IN_BCMP:
10889     case BUILT_IN_MEMCMP:
10890       return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
10891
10892     case BUILT_IN_SPRINTF:
10893       return fold_builtin_sprintf (loc, arg0, arg1, arg2, ignore);
10894
10895     case BUILT_IN_SNPRINTF:
10896       return fold_builtin_snprintf (loc, arg0, arg1, arg2, NULL_TREE, ignore);
10897
10898     case BUILT_IN_STRCPY_CHK:
10899     case BUILT_IN_STPCPY_CHK:
10900       return fold_builtin_stxcpy_chk (loc, fndecl, arg0, arg1, arg2, NULL_TREE,
10901                                       ignore, fcode);
10902
10903     case BUILT_IN_STRCAT_CHK:
10904       return fold_builtin_strcat_chk (loc, fndecl, arg0, arg1, arg2);
10905
10906     case BUILT_IN_PRINTF_CHK:
10907     case BUILT_IN_VPRINTF_CHK:
10908       if (!validate_arg (arg0, INTEGER_TYPE)
10909           || TREE_SIDE_EFFECTS (arg0))
10910         return NULL_TREE;
10911       else
10912         return fold_builtin_printf (loc, fndecl, arg1, arg2, ignore, fcode);
10913     break;
10914
10915     case BUILT_IN_FPRINTF:
10916     case BUILT_IN_FPRINTF_UNLOCKED:
10917     case BUILT_IN_VFPRINTF:
10918       return fold_builtin_fprintf (loc, fndecl, arg0, arg1, arg2,
10919                                    ignore, fcode);
10920
10921     case BUILT_IN_FPRINTF_CHK:
10922     case BUILT_IN_VFPRINTF_CHK:
10923       if (!validate_arg (arg1, INTEGER_TYPE)
10924           || TREE_SIDE_EFFECTS (arg1))
10925         return NULL_TREE;
10926       else
10927         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, NULL_TREE,
10928                                      ignore, fcode);
10929
10930     default:
10931       break;
10932     }
10933   return NULL_TREE;
10934 }
10935
10936 /* Fold a call to built-in function FNDECL with 4 arguments, ARG0, ARG1,
10937    ARG2, and ARG3.  IGNORE is true if the result of the function call is
10938    ignored.  This function returns NULL_TREE if no simplification was
10939    possible.  */
10940
10941 static tree
10942 fold_builtin_4 (location_t loc, tree fndecl,
10943                 tree arg0, tree arg1, tree arg2, tree arg3, bool ignore)
10944 {
10945   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
10946
10947   switch (fcode)
10948     {
10949     case BUILT_IN_MEMCPY_CHK:
10950     case BUILT_IN_MEMPCPY_CHK:
10951     case BUILT_IN_MEMMOVE_CHK:
10952     case BUILT_IN_MEMSET_CHK:
10953       return fold_builtin_memory_chk (loc, fndecl, arg0, arg1, arg2, arg3,
10954                                       NULL_TREE, ignore,
10955                                       DECL_FUNCTION_CODE (fndecl));
10956
10957     case BUILT_IN_STRNCPY_CHK:
10958     case BUILT_IN_STPNCPY_CHK:
10959       return fold_builtin_stxncpy_chk (loc, arg0, arg1, arg2, arg3, NULL_TREE,
10960                                        ignore, fcode);
10961
10962     case BUILT_IN_STRNCAT_CHK:
10963       return fold_builtin_strncat_chk (loc, fndecl, arg0, arg1, arg2, arg3);
10964
10965     case BUILT_IN_SNPRINTF:
10966       return fold_builtin_snprintf (loc, arg0, arg1, arg2, arg3, ignore);
10967
10968     case BUILT_IN_FPRINTF_CHK:
10969     case BUILT_IN_VFPRINTF_CHK:
10970       if (!validate_arg (arg1, INTEGER_TYPE)
10971           || TREE_SIDE_EFFECTS (arg1))
10972         return NULL_TREE;
10973       else
10974         return fold_builtin_fprintf (loc, fndecl, arg0, arg2, arg3,
10975                                      ignore, fcode);
10976     break;
10977
10978     default:
10979       break;
10980     }
10981   return NULL_TREE;
10982 }
10983
10984 /* Fold a call to built-in function FNDECL.  ARGS is an array of NARGS
10985     arguments, where NARGS <= 4.  IGNORE is true if the result of the
10986     function call is ignored.  This function returns NULL_TREE if no
10987     simplification was possible.  Note that this only folds builtins with
10988     fixed argument patterns.  Foldings that do varargs-to-varargs
10989     transformations, or that match calls with more than 4 arguments,
10990     need to be handled with fold_builtin_varargs instead.  */
10991
10992 #define MAX_ARGS_TO_FOLD_BUILTIN 4
10993
10994 static tree
10995 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool ignore)
10996 {
10997   tree ret = NULL_TREE;
10998
10999   switch (nargs)
11000     {
11001     case 0:
11002       ret = fold_builtin_0 (loc, fndecl, ignore);
11003       break;
11004     case 1:
11005       ret = fold_builtin_1 (loc, fndecl, args[0], ignore);
11006       break;
11007     case 2:
11008       ret = fold_builtin_2 (loc, fndecl, args[0], args[1], ignore);
11009       break;
11010     case 3:
11011       ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2], ignore);
11012       break;
11013     case 4:
11014       ret = fold_builtin_4 (loc, fndecl, args[0], args[1], args[2], args[3],
11015                             ignore);
11016       break;
11017     default:
11018       break;
11019     }
11020   if (ret)
11021     {
11022       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
11023       SET_EXPR_LOCATION (ret, loc);
11024       TREE_NO_WARNING (ret) = 1;
11025       return ret;
11026     }
11027   return NULL_TREE;
11028 }
11029
11030 /* Builtins with folding operations that operate on "..." arguments
11031    need special handling; we need to store the arguments in a convenient
11032    data structure before attempting any folding.  Fortunately there are
11033    only a few builtins that fall into this category.  FNDECL is the
11034    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
11035    result of the function call is ignored.  */
11036
11037 static tree
11038 fold_builtin_varargs (location_t loc, tree fndecl, tree exp,
11039                       bool ignore ATTRIBUTE_UNUSED)
11040 {
11041   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
11042   tree ret = NULL_TREE;
11043
11044   switch (fcode)
11045     {
11046     case BUILT_IN_SPRINTF_CHK:
11047     case BUILT_IN_VSPRINTF_CHK:
11048       ret = fold_builtin_sprintf_chk (loc, exp, fcode);
11049       break;
11050
11051     case BUILT_IN_SNPRINTF_CHK:
11052     case BUILT_IN_VSNPRINTF_CHK:
11053       ret = fold_builtin_snprintf_chk (loc, exp, NULL_TREE, fcode);
11054       break;
11055
11056     case BUILT_IN_FPCLASSIFY:
11057       ret = fold_builtin_fpclassify (loc, exp);
11058       break;
11059
11060     default:
11061       break;
11062     }
11063   if (ret)
11064     {
11065       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
11066       SET_EXPR_LOCATION (ret, loc);
11067       TREE_NO_WARNING (ret) = 1;
11068       return ret;
11069     }
11070   return NULL_TREE;
11071 }
11072
11073 /* Return true if FNDECL shouldn't be folded right now.
11074    If a built-in function has an inline attribute always_inline
11075    wrapper, defer folding it after always_inline functions have
11076    been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
11077    might not be performed.  */
11078
11079 bool
11080 avoid_folding_inline_builtin (tree fndecl)
11081 {
11082   return (DECL_DECLARED_INLINE_P (fndecl)
11083           && DECL_DISREGARD_INLINE_LIMITS (fndecl)
11084           && cfun
11085           && !cfun->always_inline_functions_inlined
11086           && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
11087 }
11088
11089 /* A wrapper function for builtin folding that prevents warnings for
11090    "statement without effect" and the like, caused by removing the
11091    call node earlier than the warning is generated.  */
11092
11093 tree
11094 fold_call_expr (location_t loc, tree exp, bool ignore)
11095 {
11096   tree ret = NULL_TREE;
11097   tree fndecl = get_callee_fndecl (exp);
11098   if (fndecl
11099       && TREE_CODE (fndecl) == FUNCTION_DECL
11100       && DECL_BUILT_IN (fndecl)
11101       /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
11102          yet.  Defer folding until we see all the arguments
11103          (after inlining).  */
11104       && !CALL_EXPR_VA_ARG_PACK (exp))
11105     {
11106       int nargs = call_expr_nargs (exp);
11107
11108       /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
11109          instead last argument is __builtin_va_arg_pack ().  Defer folding
11110          even in that case, until arguments are finalized.  */
11111       if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
11112         {
11113           tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
11114           if (fndecl2
11115               && TREE_CODE (fndecl2) == FUNCTION_DECL
11116               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
11117               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
11118             return NULL_TREE;
11119         }
11120
11121       if (avoid_folding_inline_builtin (fndecl))
11122         return NULL_TREE;
11123
11124       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
11125         return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
11126                                      CALL_EXPR_ARGP (exp), ignore);
11127       else
11128         {
11129           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
11130             {
11131               tree *args = CALL_EXPR_ARGP (exp);
11132               ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
11133             }
11134           if (!ret)
11135             ret = fold_builtin_varargs (loc, fndecl, exp, ignore);
11136           if (ret)
11137             return ret;
11138         }
11139     }
11140   return NULL_TREE;
11141 }
11142
11143 /* Conveniently construct a function call expression.  FNDECL names the
11144    function to be called and N arguments are passed in the array
11145    ARGARRAY.  */
11146
11147 tree
11148 build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray)
11149 {
11150   tree fntype = TREE_TYPE (fndecl);
11151   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
11152
11153   return fold_builtin_call_array (loc, TREE_TYPE (fntype), fn, n, argarray);
11154 }
11155
11156 /* Conveniently construct a function call expression.  FNDECL names the
11157    function to be called and the arguments are passed in the vector
11158    VEC.  */
11159
11160 tree
11161 build_call_expr_loc_vec (location_t loc, tree fndecl, VEC(tree,gc) *vec)
11162 {
11163   return build_call_expr_loc_array (loc, fndecl, VEC_length (tree, vec),
11164                                     VEC_address (tree, vec));
11165 }
11166
11167
11168 /* Conveniently construct a function call expression.  FNDECL names the
11169    function to be called, N is the number of arguments, and the "..."
11170    parameters are the argument expressions.  */
11171
11172 tree
11173 build_call_expr_loc (location_t loc, tree fndecl, int n, ...)
11174 {
11175   va_list ap;
11176   tree *argarray = XALLOCAVEC (tree, n);
11177   int i;
11178
11179   va_start (ap, n);
11180   for (i = 0; i < n; i++)
11181     argarray[i] = va_arg (ap, tree);
11182   va_end (ap);
11183   return build_call_expr_loc_array (loc, fndecl, n, argarray);
11184 }
11185
11186 /* Like build_call_expr_loc (UNKNOWN_LOCATION, ...).  Duplicated because
11187    varargs macros aren't supported by all bootstrap compilers.  */
11188
11189 tree
11190 build_call_expr (tree fndecl, int n, ...)
11191 {
11192   va_list ap;
11193   tree *argarray = XALLOCAVEC (tree, n);
11194   int i;
11195
11196   va_start (ap, n);
11197   for (i = 0; i < n; i++)
11198     argarray[i] = va_arg (ap, tree);
11199   va_end (ap);
11200   return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray);
11201 }
11202
11203 /* Construct a CALL_EXPR with type TYPE with FN as the function expression.
11204    N arguments are passed in the array ARGARRAY.  */
11205
11206 tree
11207 fold_builtin_call_array (location_t loc, tree type,
11208                          tree fn,
11209                          int n,
11210                          tree *argarray)
11211 {
11212   tree ret = NULL_TREE;
11213    tree exp;
11214
11215   if (TREE_CODE (fn) == ADDR_EXPR)
11216   {
11217     tree fndecl = TREE_OPERAND (fn, 0);
11218     if (TREE_CODE (fndecl) == FUNCTION_DECL
11219         && DECL_BUILT_IN (fndecl))
11220       {
11221         /* If last argument is __builtin_va_arg_pack (), arguments to this
11222            function are not finalized yet.  Defer folding until they are.  */
11223         if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
11224           {
11225             tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
11226             if (fndecl2
11227                 && TREE_CODE (fndecl2) == FUNCTION_DECL
11228                 && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
11229                 && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
11230               return build_call_array_loc (loc, type, fn, n, argarray);
11231           }
11232         if (avoid_folding_inline_builtin (fndecl))
11233           return build_call_array_loc (loc, type, fn, n, argarray);
11234         if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
11235           {
11236             ret = targetm.fold_builtin (fndecl, n, argarray, false);
11237             if (ret)
11238               return ret;
11239
11240             return build_call_array_loc (loc, type, fn, n, argarray);
11241           }
11242         else if (n <= MAX_ARGS_TO_FOLD_BUILTIN)
11243           {
11244             /* First try the transformations that don't require consing up
11245                an exp.  */
11246             ret = fold_builtin_n (loc, fndecl, argarray, n, false);
11247             if (ret)
11248               return ret;
11249           }
11250
11251         /* If we got this far, we need to build an exp.  */
11252         exp = build_call_array_loc (loc, type, fn, n, argarray);
11253         ret = fold_builtin_varargs (loc, fndecl, exp, false);
11254         return ret ? ret : exp;
11255       }
11256   }
11257
11258   return build_call_array_loc (loc, type, fn, n, argarray);
11259 }
11260
11261 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
11262    list ARGS along with N new arguments in NEWARGS.  SKIP is the number
11263    of arguments in ARGS to be omitted.  OLDNARGS is the number of
11264    elements in ARGS.  */
11265
11266 static tree
11267 rewrite_call_expr_valist (location_t loc, int oldnargs, tree *args,
11268                           int skip, tree fndecl, int n, va_list newargs)
11269 {
11270   int nargs = oldnargs - skip + n;
11271   tree *buffer;
11272
11273   if (n > 0)
11274     {
11275       int i, j;
11276
11277       buffer = XALLOCAVEC (tree, nargs);
11278       for (i = 0; i < n; i++)
11279         buffer[i] = va_arg (newargs, tree);
11280       for (j = skip; j < oldnargs; j++, i++)
11281         buffer[i] = args[j];
11282     }
11283   else
11284     buffer = args + skip;
11285
11286   return build_call_expr_loc_array (loc, fndecl, nargs, buffer);
11287 }
11288
11289 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
11290    list ARGS along with N new arguments specified as the "..."
11291    parameters.  SKIP is the number of arguments in ARGS to be omitted.
11292    OLDNARGS is the number of elements in ARGS.  */
11293
11294 static tree
11295 rewrite_call_expr_array (location_t loc, int oldnargs, tree *args,
11296                          int skip, tree fndecl, int n, ...)
11297 {
11298   va_list ap;
11299   tree t;
11300
11301   va_start (ap, n);
11302   t = rewrite_call_expr_valist (loc, oldnargs, args, skip, fndecl, n, ap);
11303   va_end (ap);
11304
11305   return t;
11306 }
11307
11308 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
11309    along with N new arguments specified as the "..." parameters.  SKIP
11310    is the number of arguments in EXP to be omitted.  This function is used
11311    to do varargs-to-varargs transformations.  */
11312
11313 static tree
11314 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
11315 {
11316   va_list ap;
11317   tree t;
11318
11319   va_start (ap, n);
11320   t = rewrite_call_expr_valist (loc, call_expr_nargs (exp),
11321                                 CALL_EXPR_ARGP (exp), skip, fndecl, n, ap);
11322   va_end (ap);
11323
11324   return t;
11325 }
11326
11327 /* Validate a single argument ARG against a tree code CODE representing
11328    a type.  */
11329
11330 static bool
11331 validate_arg (const_tree arg, enum tree_code code)
11332 {
11333   if (!arg)
11334     return false;
11335   else if (code == POINTER_TYPE)
11336     return POINTER_TYPE_P (TREE_TYPE (arg));
11337   else if (code == INTEGER_TYPE)
11338     return INTEGRAL_TYPE_P (TREE_TYPE (arg));
11339   return code == TREE_CODE (TREE_TYPE (arg));
11340 }
11341
11342 /* This function validates the types of a function call argument list
11343    against a specified list of tree_codes.  If the last specifier is a 0,
11344    that represents an ellipses, otherwise the last specifier must be a
11345    VOID_TYPE.
11346
11347    This is the GIMPLE version of validate_arglist.  Eventually we want to
11348    completely convert builtins.c to work from GIMPLEs and the tree based
11349    validate_arglist will then be removed.  */
11350
11351 bool
11352 validate_gimple_arglist (const_gimple call, ...)
11353 {
11354   enum tree_code code;
11355   bool res = 0;
11356   va_list ap;
11357   const_tree arg;
11358   size_t i;
11359
11360   va_start (ap, call);
11361   i = 0;
11362
11363   do
11364     {
11365       code = (enum tree_code) va_arg (ap, int);
11366       switch (code)
11367         {
11368         case 0:
11369           /* This signifies an ellipses, any further arguments are all ok.  */
11370           res = true;
11371           goto end;
11372         case VOID_TYPE:
11373           /* This signifies an endlink, if no arguments remain, return
11374              true, otherwise return false.  */
11375           res = (i == gimple_call_num_args (call));
11376           goto end;
11377         default:
11378           /* If no parameters remain or the parameter's code does not
11379              match the specified code, return false.  Otherwise continue
11380              checking any remaining arguments.  */
11381           arg = gimple_call_arg (call, i++);
11382           if (!validate_arg (arg, code))
11383             goto end;
11384           break;
11385         }
11386     }
11387   while (1);
11388
11389   /* We need gotos here since we can only have one VA_CLOSE in a
11390      function.  */
11391  end: ;
11392   va_end (ap);
11393
11394   return res;
11395 }
11396
11397 /* This function validates the types of a function call argument list
11398    against a specified list of tree_codes.  If the last specifier is a 0,
11399    that represents an ellipses, otherwise the last specifier must be a
11400    VOID_TYPE.  */
11401
11402 bool
11403 validate_arglist (const_tree callexpr, ...)
11404 {
11405   enum tree_code code;
11406   bool res = 0;
11407   va_list ap;
11408   const_call_expr_arg_iterator iter;
11409   const_tree arg;
11410
11411   va_start (ap, callexpr);
11412   init_const_call_expr_arg_iterator (callexpr, &iter);
11413
11414   do
11415     {
11416       code = (enum tree_code) va_arg (ap, int);
11417       switch (code)
11418         {
11419         case 0:
11420           /* This signifies an ellipses, any further arguments are all ok.  */
11421           res = true;
11422           goto end;
11423         case VOID_TYPE:
11424           /* This signifies an endlink, if no arguments remain, return
11425              true, otherwise return false.  */
11426           res = !more_const_call_expr_args_p (&iter);
11427           goto end;
11428         default:
11429           /* If no parameters remain or the parameter's code does not
11430              match the specified code, return false.  Otherwise continue
11431              checking any remaining arguments.  */
11432           arg = next_const_call_expr_arg (&iter);
11433           if (!validate_arg (arg, code))
11434             goto end;
11435           break;
11436         }
11437     }
11438   while (1);
11439
11440   /* We need gotos here since we can only have one VA_CLOSE in a
11441      function.  */
11442  end: ;
11443   va_end (ap);
11444
11445   return res;
11446 }
11447
11448 /* Default target-specific builtin expander that does nothing.  */
11449
11450 rtx
11451 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
11452                         rtx target ATTRIBUTE_UNUSED,
11453                         rtx subtarget ATTRIBUTE_UNUSED,
11454                         enum machine_mode mode ATTRIBUTE_UNUSED,
11455                         int ignore ATTRIBUTE_UNUSED)
11456 {
11457   return NULL_RTX;
11458 }
11459
11460 /* Returns true is EXP represents data that would potentially reside
11461    in a readonly section.  */
11462
11463 static bool
11464 readonly_data_expr (tree exp)
11465 {
11466   STRIP_NOPS (exp);
11467
11468   if (TREE_CODE (exp) != ADDR_EXPR)
11469     return false;
11470
11471   exp = get_base_address (TREE_OPERAND (exp, 0));
11472   if (!exp)
11473     return false;
11474
11475   /* Make sure we call decl_readonly_section only for trees it
11476      can handle (since it returns true for everything it doesn't
11477      understand).  */
11478   if (TREE_CODE (exp) == STRING_CST
11479       || TREE_CODE (exp) == CONSTRUCTOR
11480       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
11481     return decl_readonly_section (exp, 0);
11482   else
11483     return false;
11484 }
11485
11486 /* Simplify a call to the strstr builtin.  S1 and S2 are the arguments
11487    to the call, and TYPE is its return type.
11488
11489    Return NULL_TREE if no simplification was possible, otherwise return the
11490    simplified form of the call as a tree.
11491
11492    The simplified form may be a constant or other expression which
11493    computes the same value, but in a more efficient manner (including
11494    calls to other builtin functions).
11495
11496    The call may contain arguments which need to be evaluated, but
11497    which are not useful to determine the result of the call.  In
11498    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11499    COMPOUND_EXPR will be an argument which must be evaluated.
11500    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11501    COMPOUND_EXPR in the chain will contain the tree for the simplified
11502    form of the builtin function call.  */
11503
11504 static tree
11505 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
11506 {
11507   if (!validate_arg (s1, POINTER_TYPE)
11508       || !validate_arg (s2, POINTER_TYPE))
11509     return NULL_TREE;
11510   else
11511     {
11512       tree fn;
11513       const char *p1, *p2;
11514
11515       p2 = c_getstr (s2);
11516       if (p2 == NULL)
11517         return NULL_TREE;
11518
11519       p1 = c_getstr (s1);
11520       if (p1 != NULL)
11521         {
11522           const char *r = strstr (p1, p2);
11523           tree tem;
11524
11525           if (r == NULL)
11526             return build_int_cst (TREE_TYPE (s1), 0);
11527
11528           /* Return an offset into the constant string argument.  */
11529           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11530           return fold_convert_loc (loc, type, tem);
11531         }
11532
11533       /* The argument is const char *, and the result is char *, so we need
11534          a type conversion here to avoid a warning.  */
11535       if (p2[0] == '\0')
11536         return fold_convert_loc (loc, type, s1);
11537
11538       if (p2[1] != '\0')
11539         return NULL_TREE;
11540
11541       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
11542       if (!fn)
11543         return NULL_TREE;
11544
11545       /* New argument list transforming strstr(s1, s2) to
11546          strchr(s1, s2[0]).  */
11547       return build_call_expr_loc (loc, fn, 2, s1,
11548                                   build_int_cst (integer_type_node, p2[0]));
11549     }
11550 }
11551
11552 /* Simplify a call to the strchr builtin.  S1 and S2 are the arguments to
11553    the call, and TYPE is its return type.
11554
11555    Return NULL_TREE if no simplification was possible, otherwise return the
11556    simplified form of the call as a tree.
11557
11558    The simplified form may be a constant or other expression which
11559    computes the same value, but in a more efficient manner (including
11560    calls to other builtin functions).
11561
11562    The call may contain arguments which need to be evaluated, but
11563    which are not useful to determine the result of the call.  In
11564    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11565    COMPOUND_EXPR will be an argument which must be evaluated.
11566    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11567    COMPOUND_EXPR in the chain will contain the tree for the simplified
11568    form of the builtin function call.  */
11569
11570 static tree
11571 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
11572 {
11573   if (!validate_arg (s1, POINTER_TYPE)
11574       || !validate_arg (s2, INTEGER_TYPE))
11575     return NULL_TREE;
11576   else
11577     {
11578       const char *p1;
11579
11580       if (TREE_CODE (s2) != INTEGER_CST)
11581         return NULL_TREE;
11582
11583       p1 = c_getstr (s1);
11584       if (p1 != NULL)
11585         {
11586           char c;
11587           const char *r;
11588           tree tem;
11589
11590           if (target_char_cast (s2, &c))
11591             return NULL_TREE;
11592
11593           r = strchr (p1, c);
11594
11595           if (r == NULL)
11596             return build_int_cst (TREE_TYPE (s1), 0);
11597
11598           /* Return an offset into the constant string argument.  */
11599           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11600           return fold_convert_loc (loc, type, tem);
11601         }
11602       return NULL_TREE;
11603     }
11604 }
11605
11606 /* Simplify a call to the strrchr builtin.  S1 and S2 are the arguments to
11607    the call, and TYPE is its return type.
11608
11609    Return NULL_TREE if no simplification was possible, otherwise return the
11610    simplified form of the call as a tree.
11611
11612    The simplified form may be a constant or other expression which
11613    computes the same value, but in a more efficient manner (including
11614    calls to other builtin functions).
11615
11616    The call may contain arguments which need to be evaluated, but
11617    which are not useful to determine the result of the call.  In
11618    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11619    COMPOUND_EXPR will be an argument which must be evaluated.
11620    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11621    COMPOUND_EXPR in the chain will contain the tree for the simplified
11622    form of the builtin function call.  */
11623
11624 static tree
11625 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
11626 {
11627   if (!validate_arg (s1, POINTER_TYPE)
11628       || !validate_arg (s2, INTEGER_TYPE))
11629     return NULL_TREE;
11630   else
11631     {
11632       tree fn;
11633       const char *p1;
11634
11635       if (TREE_CODE (s2) != INTEGER_CST)
11636         return NULL_TREE;
11637
11638       p1 = c_getstr (s1);
11639       if (p1 != NULL)
11640         {
11641           char c;
11642           const char *r;
11643           tree tem;
11644
11645           if (target_char_cast (s2, &c))
11646             return NULL_TREE;
11647
11648           r = strrchr (p1, c);
11649
11650           if (r == NULL)
11651             return build_int_cst (TREE_TYPE (s1), 0);
11652
11653           /* Return an offset into the constant string argument.  */
11654           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11655           return fold_convert_loc (loc, type, tem);
11656         }
11657
11658       if (! integer_zerop (s2))
11659         return NULL_TREE;
11660
11661       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
11662       if (!fn)
11663         return NULL_TREE;
11664
11665       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
11666       return build_call_expr_loc (loc, fn, 2, s1, s2);
11667     }
11668 }
11669
11670 /* Simplify a call to the strpbrk builtin.  S1 and S2 are the arguments
11671    to the call, and TYPE is its return type.
11672
11673    Return NULL_TREE if no simplification was possible, otherwise return the
11674    simplified form of the call as a tree.
11675
11676    The simplified form may be a constant or other expression which
11677    computes the same value, but in a more efficient manner (including
11678    calls to other builtin functions).
11679
11680    The call may contain arguments which need to be evaluated, but
11681    which are not useful to determine the result of the call.  In
11682    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11683    COMPOUND_EXPR will be an argument which must be evaluated.
11684    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11685    COMPOUND_EXPR in the chain will contain the tree for the simplified
11686    form of the builtin function call.  */
11687
11688 static tree
11689 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
11690 {
11691   if (!validate_arg (s1, POINTER_TYPE)
11692       || !validate_arg (s2, POINTER_TYPE))
11693     return NULL_TREE;
11694   else
11695     {
11696       tree fn;
11697       const char *p1, *p2;
11698
11699       p2 = c_getstr (s2);
11700       if (p2 == NULL)
11701         return NULL_TREE;
11702
11703       p1 = c_getstr (s1);
11704       if (p1 != NULL)
11705         {
11706           const char *r = strpbrk (p1, p2);
11707           tree tem;
11708
11709           if (r == NULL)
11710             return build_int_cst (TREE_TYPE (s1), 0);
11711
11712           /* Return an offset into the constant string argument.  */
11713           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
11714           return fold_convert_loc (loc, type, tem);
11715         }
11716
11717       if (p2[0] == '\0')
11718         /* strpbrk(x, "") == NULL.
11719            Evaluate and ignore s1 in case it had side-effects.  */
11720         return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
11721
11722       if (p2[1] != '\0')
11723         return NULL_TREE;  /* Really call strpbrk.  */
11724
11725       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
11726       if (!fn)
11727         return NULL_TREE;
11728
11729       /* New argument list transforming strpbrk(s1, s2) to
11730          strchr(s1, s2[0]).  */
11731       return build_call_expr_loc (loc, fn, 2, s1,
11732                                   build_int_cst (integer_type_node, p2[0]));
11733     }
11734 }
11735
11736 /* Simplify a call to the strcat builtin.  DST and SRC are the arguments
11737    to the call.
11738
11739    Return NULL_TREE if no simplification was possible, otherwise return the
11740    simplified form of the call as a tree.
11741
11742    The simplified form may be a constant or other expression which
11743    computes the same value, but in a more efficient manner (including
11744    calls to other builtin functions).
11745
11746    The call may contain arguments which need to be evaluated, but
11747    which are not useful to determine the result of the call.  In
11748    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11749    COMPOUND_EXPR will be an argument which must be evaluated.
11750    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11751    COMPOUND_EXPR in the chain will contain the tree for the simplified
11752    form of the builtin function call.  */
11753
11754 static tree
11755 fold_builtin_strcat (location_t loc ATTRIBUTE_UNUSED, tree dst, tree src)
11756 {
11757   if (!validate_arg (dst, POINTER_TYPE)
11758       || !validate_arg (src, POINTER_TYPE))
11759     return NULL_TREE;
11760   else
11761     {
11762       const char *p = c_getstr (src);
11763
11764       /* If the string length is zero, return the dst parameter.  */
11765       if (p && *p == '\0')
11766         return dst;
11767
11768       if (optimize_insn_for_speed_p ())
11769         {
11770           /* See if we can store by pieces into (dst + strlen(dst)).  */
11771           tree newdst, call;
11772           tree strlen_fn = builtin_decl_implicit (BUILT_IN_STRLEN);
11773           tree strcpy_fn = builtin_decl_implicit (BUILT_IN_STRCPY);
11774
11775           if (!strlen_fn || !strcpy_fn)
11776             return NULL_TREE;
11777
11778           /* If we don't have a movstr we don't want to emit an strcpy
11779              call.  We have to do that if the length of the source string
11780              isn't computable (in that case we can use memcpy probably
11781              later expanding to a sequence of mov instructions).  If we
11782              have movstr instructions we can emit strcpy calls.  */
11783           if (!HAVE_movstr)
11784             {
11785               tree len = c_strlen (src, 1);
11786               if (! len || TREE_SIDE_EFFECTS (len))
11787                 return NULL_TREE;
11788             }
11789
11790           /* Stabilize the argument list.  */
11791           dst = builtin_save_expr (dst);
11792
11793           /* Create strlen (dst).  */
11794           newdst = build_call_expr_loc (loc, strlen_fn, 1, dst);
11795           /* Create (dst p+ strlen (dst)).  */
11796
11797           newdst = fold_build_pointer_plus_loc (loc, dst, newdst);
11798           newdst = builtin_save_expr (newdst);
11799
11800           call = build_call_expr_loc (loc, strcpy_fn, 2, newdst, src);
11801           return build2 (COMPOUND_EXPR, TREE_TYPE (dst), call, dst);
11802         }
11803       return NULL_TREE;
11804     }
11805 }
11806
11807 /* Simplify a call to the strncat builtin.  DST, SRC, and LEN are the
11808    arguments to the call.
11809
11810    Return NULL_TREE if no simplification was possible, otherwise return the
11811    simplified form of the call as a tree.
11812
11813    The simplified form may be a constant or other expression which
11814    computes the same value, but in a more efficient manner (including
11815    calls to other builtin functions).
11816
11817    The call may contain arguments which need to be evaluated, but
11818    which are not useful to determine the result of the call.  In
11819    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11820    COMPOUND_EXPR will be an argument which must be evaluated.
11821    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11822    COMPOUND_EXPR in the chain will contain the tree for the simplified
11823    form of the builtin function call.  */
11824
11825 static tree
11826 fold_builtin_strncat (location_t loc, tree dst, tree src, tree len)
11827 {
11828   if (!validate_arg (dst, POINTER_TYPE)
11829       || !validate_arg (src, POINTER_TYPE)
11830       || !validate_arg (len, INTEGER_TYPE))
11831     return NULL_TREE;
11832   else
11833     {
11834       const char *p = c_getstr (src);
11835
11836       /* If the requested length is zero, or the src parameter string
11837          length is zero, return the dst parameter.  */
11838       if (integer_zerop (len) || (p && *p == '\0'))
11839         return omit_two_operands_loc (loc, TREE_TYPE (dst), dst, src, len);
11840
11841       /* If the requested len is greater than or equal to the string
11842          length, call strcat.  */
11843       if (TREE_CODE (len) == INTEGER_CST && p
11844           && compare_tree_int (len, strlen (p)) >= 0)
11845         {
11846           tree fn = builtin_decl_implicit (BUILT_IN_STRCAT);
11847
11848           /* If the replacement _DECL isn't initialized, don't do the
11849              transformation.  */
11850           if (!fn)
11851             return NULL_TREE;
11852
11853           return build_call_expr_loc (loc, fn, 2, dst, src);
11854         }
11855       return NULL_TREE;
11856     }
11857 }
11858
11859 /* Simplify a call to the strspn builtin.  S1 and S2 are the arguments
11860    to the call.
11861
11862    Return NULL_TREE if no simplification was possible, otherwise return the
11863    simplified form of the call as a tree.
11864
11865    The simplified form may be a constant or other expression which
11866    computes the same value, but in a more efficient manner (including
11867    calls to other builtin functions).
11868
11869    The call may contain arguments which need to be evaluated, but
11870    which are not useful to determine the result of the call.  In
11871    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11872    COMPOUND_EXPR will be an argument which must be evaluated.
11873    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11874    COMPOUND_EXPR in the chain will contain the tree for the simplified
11875    form of the builtin function call.  */
11876
11877 static tree
11878 fold_builtin_strspn (location_t loc, tree s1, tree s2)
11879 {
11880   if (!validate_arg (s1, POINTER_TYPE)
11881       || !validate_arg (s2, POINTER_TYPE))
11882     return NULL_TREE;
11883   else
11884     {
11885       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11886
11887       /* If both arguments are constants, evaluate at compile-time.  */
11888       if (p1 && p2)
11889         {
11890           const size_t r = strspn (p1, p2);
11891           return size_int (r);
11892         }
11893
11894       /* If either argument is "", return NULL_TREE.  */
11895       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
11896         /* Evaluate and ignore both arguments in case either one has
11897            side-effects.  */
11898         return omit_two_operands_loc (loc, size_type_node, size_zero_node,
11899                                   s1, s2);
11900       return NULL_TREE;
11901     }
11902 }
11903
11904 /* Simplify a call to the strcspn builtin.  S1 and S2 are the arguments
11905    to the call.
11906
11907    Return NULL_TREE if no simplification was possible, otherwise return the
11908    simplified form of the call as a tree.
11909
11910    The simplified form may be a constant or other expression which
11911    computes the same value, but in a more efficient manner (including
11912    calls to other builtin functions).
11913
11914    The call may contain arguments which need to be evaluated, but
11915    which are not useful to determine the result of the call.  In
11916    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
11917    COMPOUND_EXPR will be an argument which must be evaluated.
11918    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
11919    COMPOUND_EXPR in the chain will contain the tree for the simplified
11920    form of the builtin function call.  */
11921
11922 static tree
11923 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
11924 {
11925   if (!validate_arg (s1, POINTER_TYPE)
11926       || !validate_arg (s2, POINTER_TYPE))
11927     return NULL_TREE;
11928   else
11929     {
11930       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
11931
11932       /* If both arguments are constants, evaluate at compile-time.  */
11933       if (p1 && p2)
11934         {
11935           const size_t r = strcspn (p1, p2);
11936           return size_int (r);
11937         }
11938
11939       /* If the first argument is "", return NULL_TREE.  */
11940       if (p1 && *p1 == '\0')
11941         {
11942           /* Evaluate and ignore argument s2 in case it has
11943              side-effects.  */
11944           return omit_one_operand_loc (loc, size_type_node,
11945                                    size_zero_node, s2);
11946         }
11947
11948       /* If the second argument is "", return __builtin_strlen(s1).  */
11949       if (p2 && *p2 == '\0')
11950         {
11951           tree fn = builtin_decl_implicit (BUILT_IN_STRLEN);
11952
11953           /* If the replacement _DECL isn't initialized, don't do the
11954              transformation.  */
11955           if (!fn)
11956             return NULL_TREE;
11957
11958           return build_call_expr_loc (loc, fn, 1, s1);
11959         }
11960       return NULL_TREE;
11961     }
11962 }
11963
11964 /* Fold a call to the fputs builtin.  ARG0 and ARG1 are the arguments
11965    to the call.  IGNORE is true if the value returned
11966    by the builtin will be ignored.  UNLOCKED is true is true if this
11967    actually a call to fputs_unlocked.  If LEN in non-NULL, it represents
11968    the known length of the string.  Return NULL_TREE if no simplification
11969    was possible.  */
11970
11971 tree
11972 fold_builtin_fputs (location_t loc, tree arg0, tree arg1,
11973                     bool ignore, bool unlocked, tree len)
11974 {
11975   /* If we're using an unlocked function, assume the other unlocked
11976      functions exist explicitly.  */
11977   tree const fn_fputc = (unlocked
11978                          ? builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED)
11979                          : builtin_decl_implicit (BUILT_IN_FPUTC));
11980   tree const fn_fwrite = (unlocked
11981                           ? builtin_decl_explicit (BUILT_IN_FWRITE_UNLOCKED)
11982                           : builtin_decl_implicit (BUILT_IN_FWRITE));
11983
11984   /* If the return value is used, don't do the transformation.  */
11985   if (!ignore)
11986     return NULL_TREE;
11987
11988   /* Verify the arguments in the original call.  */
11989   if (!validate_arg (arg0, POINTER_TYPE)
11990       || !validate_arg (arg1, POINTER_TYPE))
11991     return NULL_TREE;
11992
11993   if (! len)
11994     len = c_strlen (arg0, 0);
11995
11996   /* Get the length of the string passed to fputs.  If the length
11997      can't be determined, punt.  */
11998   if (!len
11999       || TREE_CODE (len) != INTEGER_CST)
12000     return NULL_TREE;
12001
12002   switch (compare_tree_int (len, 1))
12003     {
12004     case -1: /* length is 0, delete the call entirely .  */
12005       return omit_one_operand_loc (loc, integer_type_node,
12006                                integer_zero_node, arg1);;
12007
12008     case 0: /* length is 1, call fputc.  */
12009       {
12010         const char *p = c_getstr (arg0);
12011
12012         if (p != NULL)
12013           {
12014             if (fn_fputc)
12015               return build_call_expr_loc (loc, fn_fputc, 2,
12016                                           build_int_cst
12017                                             (integer_type_node, p[0]), arg1);
12018             else
12019               return NULL_TREE;
12020           }
12021       }
12022       /* FALLTHROUGH */
12023     case 1: /* length is greater than 1, call fwrite.  */
12024       {
12025         /* If optimizing for size keep fputs.  */
12026         if (optimize_function_for_size_p (cfun))
12027           return NULL_TREE;
12028         /* New argument list transforming fputs(string, stream) to
12029            fwrite(string, 1, len, stream).  */
12030         if (fn_fwrite)
12031           return build_call_expr_loc (loc, fn_fwrite, 4, arg0,
12032                                   size_one_node, len, arg1);
12033         else
12034           return NULL_TREE;
12035       }
12036     default:
12037       gcc_unreachable ();
12038     }
12039   return NULL_TREE;
12040 }
12041
12042 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
12043    produced.  False otherwise.  This is done so that we don't output the error
12044    or warning twice or three times.  */
12045
12046 bool
12047 fold_builtin_next_arg (tree exp, bool va_start_p)
12048 {
12049   tree fntype = TREE_TYPE (current_function_decl);
12050   int nargs = call_expr_nargs (exp);
12051   tree arg;
12052   /* There is good chance the current input_location points inside the
12053      definition of the va_start macro (perhaps on the token for
12054      builtin) in a system header, so warnings will not be emitted.
12055      Use the location in real source code.  */
12056   source_location current_location =
12057     linemap_unwind_to_first_non_reserved_loc (line_table, input_location,
12058                                               NULL);
12059
12060   if (!stdarg_p (fntype))
12061     {
12062       error ("%<va_start%> used in function with fixed args");
12063       return true;
12064     }
12065
12066   if (va_start_p)
12067     {
12068       if (va_start_p && (nargs != 2))
12069         {
12070           error ("wrong number of arguments to function %<va_start%>");
12071           return true;
12072         }
12073       arg = CALL_EXPR_ARG (exp, 1);
12074     }
12075   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
12076      when we checked the arguments and if needed issued a warning.  */
12077   else
12078     {
12079       if (nargs == 0)
12080         {
12081           /* Evidently an out of date version of <stdarg.h>; can't validate
12082              va_start's second argument, but can still work as intended.  */
12083           warning_at (current_location,
12084                       OPT_Wvarargs,
12085                    "%<__builtin_next_arg%> called without an argument");
12086           return true;
12087         }
12088       else if (nargs > 1)
12089         {
12090           error ("wrong number of arguments to function %<__builtin_next_arg%>");
12091           return true;
12092         }
12093       arg = CALL_EXPR_ARG (exp, 0);
12094     }
12095
12096   if (TREE_CODE (arg) == SSA_NAME)
12097     arg = SSA_NAME_VAR (arg);
12098
12099   /* We destructively modify the call to be __builtin_va_start (ap, 0)
12100      or __builtin_next_arg (0) the first time we see it, after checking
12101      the arguments and if needed issuing a warning.  */
12102   if (!integer_zerop (arg))
12103     {
12104       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
12105
12106       /* Strip off all nops for the sake of the comparison.  This
12107          is not quite the same as STRIP_NOPS.  It does more.
12108          We must also strip off INDIRECT_EXPR for C++ reference
12109          parameters.  */
12110       while (CONVERT_EXPR_P (arg)
12111              || TREE_CODE (arg) == INDIRECT_REF)
12112         arg = TREE_OPERAND (arg, 0);
12113       if (arg != last_parm)
12114         {
12115           /* FIXME: Sometimes with the tree optimizers we can get the
12116              not the last argument even though the user used the last
12117              argument.  We just warn and set the arg to be the last
12118              argument so that we will get wrong-code because of
12119              it.  */
12120           warning_at (current_location,
12121                       OPT_Wvarargs,
12122                       "second parameter of %<va_start%> not last named argument");
12123         }
12124
12125       /* Undefined by C99 7.15.1.4p4 (va_start):
12126          "If the parameter parmN is declared with the register storage
12127          class, with a function or array type, or with a type that is
12128          not compatible with the type that results after application of
12129          the default argument promotions, the behavior is undefined."
12130       */
12131       else if (DECL_REGISTER (arg))
12132         {
12133           warning_at (current_location,
12134                       OPT_Wvarargs,
12135                       "undefined behaviour when second parameter of "
12136                       "%<va_start%> is declared with %<register%> storage");
12137         }
12138
12139       /* We want to verify the second parameter just once before the tree
12140          optimizers are run and then avoid keeping it in the tree,
12141          as otherwise we could warn even for correct code like:
12142          void foo (int i, ...)
12143          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
12144       if (va_start_p)
12145         CALL_EXPR_ARG (exp, 1) = integer_zero_node;
12146       else
12147         CALL_EXPR_ARG (exp, 0) = integer_zero_node;
12148     }
12149   return false;
12150 }
12151
12152
12153 /* Simplify a call to the sprintf builtin with arguments DEST, FMT, and ORIG.
12154    ORIG may be null if this is a 2-argument call.  We don't attempt to
12155    simplify calls with more than 3 arguments.
12156
12157    Return NULL_TREE if no simplification was possible, otherwise return the
12158    simplified form of the call as a tree.  If IGNORED is true, it means that
12159    the caller does not use the returned value of the function.  */
12160
12161 static tree
12162 fold_builtin_sprintf (location_t loc, tree dest, tree fmt,
12163                       tree orig, int ignored)
12164 {
12165   tree call, retval;
12166   const char *fmt_str = NULL;
12167
12168   /* Verify the required arguments in the original call.  We deal with two
12169      types of sprintf() calls: 'sprintf (str, fmt)' and
12170      'sprintf (dest, "%s", orig)'.  */
12171   if (!validate_arg (dest, POINTER_TYPE)
12172       || !validate_arg (fmt, POINTER_TYPE))
12173     return NULL_TREE;
12174   if (orig && !validate_arg (orig, POINTER_TYPE))
12175     return NULL_TREE;
12176
12177   /* Check whether the format is a literal string constant.  */
12178   fmt_str = c_getstr (fmt);
12179   if (fmt_str == NULL)
12180     return NULL_TREE;
12181
12182   call = NULL_TREE;
12183   retval = NULL_TREE;
12184
12185   if (!init_target_chars ())
12186     return NULL_TREE;
12187
12188   /* If the format doesn't contain % args or %%, use strcpy.  */
12189   if (strchr (fmt_str, target_percent) == NULL)
12190     {
12191       tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12192
12193       if (!fn)
12194         return NULL_TREE;
12195
12196       /* Don't optimize sprintf (buf, "abc", ptr++).  */
12197       if (orig)
12198         return NULL_TREE;
12199
12200       /* Convert sprintf (str, fmt) into strcpy (str, fmt) when
12201          'format' is known to contain no % formats.  */
12202       call = build_call_expr_loc (loc, fn, 2, dest, fmt);
12203       if (!ignored)
12204         retval = build_int_cst (integer_type_node, strlen (fmt_str));
12205     }
12206
12207   /* If the format is "%s", use strcpy if the result isn't used.  */
12208   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
12209     {
12210       tree fn;
12211       fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12212
12213       if (!fn)
12214         return NULL_TREE;
12215
12216       /* Don't crash on sprintf (str1, "%s").  */
12217       if (!orig)
12218         return NULL_TREE;
12219
12220       /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2).  */
12221       if (!ignored)
12222         {
12223           retval = c_strlen (orig, 1);
12224           if (!retval || TREE_CODE (retval) != INTEGER_CST)
12225             return NULL_TREE;
12226         }
12227       call = build_call_expr_loc (loc, fn, 2, dest, orig);
12228     }
12229
12230   if (call && retval)
12231     {
12232       retval = fold_convert_loc
12233         (loc, TREE_TYPE (TREE_TYPE (builtin_decl_implicit (BUILT_IN_SPRINTF))),
12234          retval);
12235       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
12236     }
12237   else
12238     return call;
12239 }
12240
12241 /* Simplify a call to the snprintf builtin with arguments DEST, DESTSIZE,
12242    FMT, and ORIG.  ORIG may be null if this is a 3-argument call.  We don't
12243    attempt to simplify calls with more than 4 arguments.
12244
12245    Return NULL_TREE if no simplification was possible, otherwise return the
12246    simplified form of the call as a tree.  If IGNORED is true, it means that
12247    the caller does not use the returned value of the function.  */
12248
12249 static tree
12250 fold_builtin_snprintf (location_t loc, tree dest, tree destsize, tree fmt,
12251                        tree orig, int ignored)
12252 {
12253   tree call, retval;
12254   const char *fmt_str = NULL;
12255   unsigned HOST_WIDE_INT destlen;
12256
12257   /* Verify the required arguments in the original call.  We deal with two
12258      types of snprintf() calls: 'snprintf (str, cst, fmt)' and
12259      'snprintf (dest, cst, "%s", orig)'.  */
12260   if (!validate_arg (dest, POINTER_TYPE)
12261       || !validate_arg (destsize, INTEGER_TYPE)
12262       || !validate_arg (fmt, POINTER_TYPE))
12263     return NULL_TREE;
12264   if (orig && !validate_arg (orig, POINTER_TYPE))
12265     return NULL_TREE;
12266
12267   if (!host_integerp (destsize, 1))
12268     return NULL_TREE;
12269
12270   /* Check whether the format is a literal string constant.  */
12271   fmt_str = c_getstr (fmt);
12272   if (fmt_str == NULL)
12273     return NULL_TREE;
12274
12275   call = NULL_TREE;
12276   retval = NULL_TREE;
12277
12278   if (!init_target_chars ())
12279     return NULL_TREE;
12280
12281   destlen = tree_low_cst (destsize, 1);
12282
12283   /* If the format doesn't contain % args or %%, use strcpy.  */
12284   if (strchr (fmt_str, target_percent) == NULL)
12285     {
12286       tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12287       size_t len = strlen (fmt_str);
12288
12289       /* Don't optimize snprintf (buf, 4, "abc", ptr++).  */
12290       if (orig)
12291         return NULL_TREE;
12292
12293       /* We could expand this as
12294          memcpy (str, fmt, cst - 1); str[cst - 1] = '\0';
12295          or to
12296          memcpy (str, fmt_with_nul_at_cstm1, cst);
12297          but in the former case that might increase code size
12298          and in the latter case grow .rodata section too much.
12299          So punt for now.  */
12300       if (len >= destlen)
12301         return NULL_TREE;
12302
12303       if (!fn)
12304         return NULL_TREE;
12305
12306       /* Convert snprintf (str, cst, fmt) into strcpy (str, fmt) when
12307          'format' is known to contain no % formats and
12308          strlen (fmt) < cst.  */
12309       call = build_call_expr_loc (loc, fn, 2, dest, fmt);
12310
12311       if (!ignored)
12312         retval = build_int_cst (integer_type_node, strlen (fmt_str));
12313     }
12314
12315   /* If the format is "%s", use strcpy if the result isn't used.  */
12316   else if (fmt_str && strcmp (fmt_str, target_percent_s) == 0)
12317     {
12318       tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
12319       unsigned HOST_WIDE_INT origlen;
12320
12321       /* Don't crash on snprintf (str1, cst, "%s").  */
12322       if (!orig)
12323         return NULL_TREE;
12324
12325       retval = c_strlen (orig, 1);
12326       if (!retval || !host_integerp (retval, 1))
12327         return NULL_TREE;
12328
12329       origlen = tree_low_cst (retval, 1);
12330       /* We could expand this as
12331          memcpy (str1, str2, cst - 1); str1[cst - 1] = '\0';
12332          or to
12333          memcpy (str1, str2_with_nul_at_cstm1, cst);
12334          but in the former case that might increase code size
12335          and in the latter case grow .rodata section too much.
12336          So punt for now.  */
12337       if (origlen >= destlen)
12338         return NULL_TREE;
12339
12340       /* Convert snprintf (str1, cst, "%s", str2) into
12341          strcpy (str1, str2) if strlen (str2) < cst.  */
12342       if (!fn)
12343         return NULL_TREE;
12344
12345       call = build_call_expr_loc (loc, fn, 2, dest, orig);
12346
12347       if (ignored)
12348         retval = NULL_TREE;
12349     }
12350
12351   if (call && retval)
12352     {
12353       tree fn = builtin_decl_explicit (BUILT_IN_SNPRINTF);
12354       retval = fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fn)), retval);
12355       return build2 (COMPOUND_EXPR, TREE_TYPE (retval), call, retval);
12356     }
12357   else
12358     return call;
12359 }
12360
12361 /* Expand a call EXP to __builtin_object_size.  */
12362
12363 rtx
12364 expand_builtin_object_size (tree exp)
12365 {
12366   tree ost;
12367   int object_size_type;
12368   tree fndecl = get_callee_fndecl (exp);
12369
12370   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
12371     {
12372       error ("%Kfirst argument of %D must be a pointer, second integer constant",
12373              exp, fndecl);
12374       expand_builtin_trap ();
12375       return const0_rtx;
12376     }
12377
12378   ost = CALL_EXPR_ARG (exp, 1);
12379   STRIP_NOPS (ost);
12380
12381   if (TREE_CODE (ost) != INTEGER_CST
12382       || tree_int_cst_sgn (ost) < 0
12383       || compare_tree_int (ost, 3) > 0)
12384     {
12385       error ("%Klast argument of %D is not integer constant between 0 and 3",
12386              exp, fndecl);
12387       expand_builtin_trap ();
12388       return const0_rtx;
12389     }
12390
12391   object_size_type = tree_low_cst (ost, 0);
12392
12393   return object_size_type < 2 ? constm1_rtx : const0_rtx;
12394 }
12395
12396 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12397    FCODE is the BUILT_IN_* to use.
12398    Return NULL_RTX if we failed; the caller should emit a normal call,
12399    otherwise try to get the result in TARGET, if convenient (and in
12400    mode MODE if that's convenient).  */
12401
12402 static rtx
12403 expand_builtin_memory_chk (tree exp, rtx target, enum machine_mode mode,
12404                            enum built_in_function fcode)
12405 {
12406   tree dest, src, len, size;
12407
12408   if (!validate_arglist (exp,
12409                          POINTER_TYPE,
12410                          fcode == BUILT_IN_MEMSET_CHK
12411                          ? INTEGER_TYPE : POINTER_TYPE,
12412                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
12413     return NULL_RTX;
12414
12415   dest = CALL_EXPR_ARG (exp, 0);
12416   src = CALL_EXPR_ARG (exp, 1);
12417   len = CALL_EXPR_ARG (exp, 2);
12418   size = CALL_EXPR_ARG (exp, 3);
12419
12420   if (! host_integerp (size, 1))
12421     return NULL_RTX;
12422
12423   if (host_integerp (len, 1) || integer_all_onesp (size))
12424     {
12425       tree fn;
12426
12427       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
12428         {
12429           warning_at (tree_nonartificial_location (exp),
12430                       0, "%Kcall to %D will always overflow destination buffer",
12431                       exp, get_callee_fndecl (exp));
12432           return NULL_RTX;
12433         }
12434
12435       fn = NULL_TREE;
12436       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12437          mem{cpy,pcpy,move,set} is available.  */
12438       switch (fcode)
12439         {
12440         case BUILT_IN_MEMCPY_CHK:
12441           fn = builtin_decl_explicit (BUILT_IN_MEMCPY);
12442           break;
12443         case BUILT_IN_MEMPCPY_CHK:
12444           fn = builtin_decl_explicit (BUILT_IN_MEMPCPY);
12445           break;
12446         case BUILT_IN_MEMMOVE_CHK:
12447           fn = builtin_decl_explicit (BUILT_IN_MEMMOVE);
12448           break;
12449         case BUILT_IN_MEMSET_CHK:
12450           fn = builtin_decl_explicit (BUILT_IN_MEMSET);
12451           break;
12452         default:
12453           break;
12454         }
12455
12456       if (! fn)
12457         return NULL_RTX;
12458
12459       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
12460       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12461       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12462       return expand_expr (fn, target, mode, EXPAND_NORMAL);
12463     }
12464   else if (fcode == BUILT_IN_MEMSET_CHK)
12465     return NULL_RTX;
12466   else
12467     {
12468       unsigned int dest_align = get_pointer_alignment (dest);
12469
12470       /* If DEST is not a pointer type, call the normal function.  */
12471       if (dest_align == 0)
12472         return NULL_RTX;
12473
12474       /* If SRC and DEST are the same (and not volatile), do nothing.  */
12475       if (operand_equal_p (src, dest, 0))
12476         {
12477           tree expr;
12478
12479           if (fcode != BUILT_IN_MEMPCPY_CHK)
12480             {
12481               /* Evaluate and ignore LEN in case it has side-effects.  */
12482               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
12483               return expand_expr (dest, target, mode, EXPAND_NORMAL);
12484             }
12485
12486           expr = fold_build_pointer_plus (dest, len);
12487           return expand_expr (expr, target, mode, EXPAND_NORMAL);
12488         }
12489
12490       /* __memmove_chk special case.  */
12491       if (fcode == BUILT_IN_MEMMOVE_CHK)
12492         {
12493           unsigned int src_align = get_pointer_alignment (src);
12494
12495           if (src_align == 0)
12496             return NULL_RTX;
12497
12498           /* If src is categorized for a readonly section we can use
12499              normal __memcpy_chk.  */
12500           if (readonly_data_expr (src))
12501             {
12502               tree fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
12503               if (!fn)
12504                 return NULL_RTX;
12505               fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
12506                                           dest, src, len, size);
12507               gcc_assert (TREE_CODE (fn) == CALL_EXPR);
12508               CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
12509               return expand_expr (fn, target, mode, EXPAND_NORMAL);
12510             }
12511         }
12512       return NULL_RTX;
12513     }
12514 }
12515
12516 /* Emit warning if a buffer overflow is detected at compile time.  */
12517
12518 static void
12519 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
12520 {
12521   int is_strlen = 0;
12522   tree len, size;
12523   location_t loc = tree_nonartificial_location (exp);
12524
12525   switch (fcode)
12526     {
12527     case BUILT_IN_STRCPY_CHK:
12528     case BUILT_IN_STPCPY_CHK:
12529     /* For __strcat_chk the warning will be emitted only if overflowing
12530        by at least strlen (dest) + 1 bytes.  */
12531     case BUILT_IN_STRCAT_CHK:
12532       len = CALL_EXPR_ARG (exp, 1);
12533       size = CALL_EXPR_ARG (exp, 2);
12534       is_strlen = 1;
12535       break;
12536     case BUILT_IN_STRNCAT_CHK:
12537     case BUILT_IN_STRNCPY_CHK:
12538     case BUILT_IN_STPNCPY_CHK:
12539       len = CALL_EXPR_ARG (exp, 2);
12540       size = CALL_EXPR_ARG (exp, 3);
12541       break;
12542     case BUILT_IN_SNPRINTF_CHK:
12543     case BUILT_IN_VSNPRINTF_CHK:
12544       len = CALL_EXPR_ARG (exp, 1);
12545       size = CALL_EXPR_ARG (exp, 3);
12546       break;
12547     default:
12548       gcc_unreachable ();
12549     }
12550
12551   if (!len || !size)
12552     return;
12553
12554   if (! host_integerp (size, 1) || integer_all_onesp (size))
12555     return;
12556
12557   if (is_strlen)
12558     {
12559       len = c_strlen (len, 1);
12560       if (! len || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12561         return;
12562     }
12563   else if (fcode == BUILT_IN_STRNCAT_CHK)
12564     {
12565       tree src = CALL_EXPR_ARG (exp, 1);
12566       if (! src || ! host_integerp (len, 1) || tree_int_cst_lt (len, size))
12567         return;
12568       src = c_strlen (src, 1);
12569       if (! src || ! host_integerp (src, 1))
12570         {
12571           warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
12572                       exp, get_callee_fndecl (exp));
12573           return;
12574         }
12575       else if (tree_int_cst_lt (src, size))
12576         return;
12577     }
12578   else if (! host_integerp (len, 1) || ! tree_int_cst_lt (size, len))
12579     return;
12580
12581   warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
12582               exp, get_callee_fndecl (exp));
12583 }
12584
12585 /* Emit warning if a buffer overflow is detected at compile time
12586    in __sprintf_chk/__vsprintf_chk calls.  */
12587
12588 static void
12589 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
12590 {
12591   tree size, len, fmt;
12592   const char *fmt_str;
12593   int nargs = call_expr_nargs (exp);
12594
12595   /* Verify the required arguments in the original call.  */
12596
12597   if (nargs < 4)
12598     return;
12599   size = CALL_EXPR_ARG (exp, 2);
12600   fmt = CALL_EXPR_ARG (exp, 3);
12601
12602   if (! host_integerp (size, 1) || integer_all_onesp (size))
12603     return;
12604
12605   /* Check whether the format is a literal string constant.  */
12606   fmt_str = c_getstr (fmt);
12607   if (fmt_str == NULL)
12608     return;
12609
12610   if (!init_target_chars ())
12611     return;
12612
12613   /* If the format doesn't contain % args or %%, we know its size.  */
12614   if (strchr (fmt_str, target_percent) == 0)
12615     len = build_int_cstu (size_type_node, strlen (fmt_str));
12616   /* If the format is "%s" and first ... argument is a string literal,
12617      we know it too.  */
12618   else if (fcode == BUILT_IN_SPRINTF_CHK
12619            && strcmp (fmt_str, target_percent_s) == 0)
12620     {
12621       tree arg;
12622
12623       if (nargs < 5)
12624         return;
12625       arg = CALL_EXPR_ARG (exp, 4);
12626       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
12627         return;
12628
12629       len = c_strlen (arg, 1);
12630       if (!len || ! host_integerp (len, 1))
12631         return;
12632     }
12633   else
12634     return;
12635
12636   if (! tree_int_cst_lt (len, size))
12637     warning_at (tree_nonartificial_location (exp),
12638                 0, "%Kcall to %D will always overflow destination buffer",
12639                 exp, get_callee_fndecl (exp));
12640 }
12641
12642 /* Emit warning if a free is called with address of a variable.  */
12643
12644 static void
12645 maybe_emit_free_warning (tree exp)
12646 {
12647   tree arg = CALL_EXPR_ARG (exp, 0);
12648
12649   STRIP_NOPS (arg);
12650   if (TREE_CODE (arg) != ADDR_EXPR)
12651     return;
12652
12653   arg = get_base_address (TREE_OPERAND (arg, 0));
12654   if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
12655     return;
12656
12657   if (SSA_VAR_P (arg))
12658     warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
12659                 "%Kattempt to free a non-heap object %qD", exp, arg);
12660   else
12661     warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
12662                 "%Kattempt to free a non-heap object", exp);
12663 }
12664
12665 /* Fold a call to __builtin_object_size with arguments PTR and OST,
12666    if possible.  */
12667
12668 tree
12669 fold_builtin_object_size (tree ptr, tree ost)
12670 {
12671   unsigned HOST_WIDE_INT bytes;
12672   int object_size_type;
12673
12674   if (!validate_arg (ptr, POINTER_TYPE)
12675       || !validate_arg (ost, INTEGER_TYPE))
12676     return NULL_TREE;
12677
12678   STRIP_NOPS (ost);
12679
12680   if (TREE_CODE (ost) != INTEGER_CST
12681       || tree_int_cst_sgn (ost) < 0
12682       || compare_tree_int (ost, 3) > 0)
12683     return NULL_TREE;
12684
12685   object_size_type = tree_low_cst (ost, 0);
12686
12687   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
12688      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
12689      and (size_t) 0 for types 2 and 3.  */
12690   if (TREE_SIDE_EFFECTS (ptr))
12691     return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
12692
12693   if (TREE_CODE (ptr) == ADDR_EXPR)
12694     {
12695       bytes = compute_builtin_object_size (ptr, object_size_type);
12696       if (double_int_fits_to_tree_p (size_type_node,
12697                                      uhwi_to_double_int (bytes)))
12698         return build_int_cstu (size_type_node, bytes);
12699     }
12700   else if (TREE_CODE (ptr) == SSA_NAME)
12701     {
12702       /* If object size is not known yet, delay folding until
12703        later.  Maybe subsequent passes will help determining
12704        it.  */
12705       bytes = compute_builtin_object_size (ptr, object_size_type);
12706       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
12707           && double_int_fits_to_tree_p (size_type_node,
12708                                         uhwi_to_double_int (bytes)))
12709         return build_int_cstu (size_type_node, bytes);
12710     }
12711
12712   return NULL_TREE;
12713 }
12714
12715 /* Fold a call to the __mem{cpy,pcpy,move,set}_chk builtin.
12716    DEST, SRC, LEN, and SIZE are the arguments to the call.
12717    IGNORE is true, if return value can be ignored.  FCODE is the BUILT_IN_*
12718    code of the builtin.  If MAXLEN is not NULL, it is maximum length
12719    passed as third argument.  */
12720
12721 tree
12722 fold_builtin_memory_chk (location_t loc, tree fndecl,
12723                          tree dest, tree src, tree len, tree size,
12724                          tree maxlen, bool ignore,
12725                          enum built_in_function fcode)
12726 {
12727   tree fn;
12728
12729   if (!validate_arg (dest, POINTER_TYPE)
12730       || !validate_arg (src,
12731                         (fcode == BUILT_IN_MEMSET_CHK
12732                          ? INTEGER_TYPE : POINTER_TYPE))
12733       || !validate_arg (len, INTEGER_TYPE)
12734       || !validate_arg (size, INTEGER_TYPE))
12735     return NULL_TREE;
12736
12737   /* If SRC and DEST are the same (and not volatile), return DEST
12738      (resp. DEST+LEN for __mempcpy_chk).  */
12739   if (fcode != BUILT_IN_MEMSET_CHK && operand_equal_p (src, dest, 0))
12740     {
12741       if (fcode != BUILT_IN_MEMPCPY_CHK)
12742         return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12743                                  dest, len);
12744       else
12745         {
12746           tree temp = fold_build_pointer_plus_loc (loc, dest, len);
12747           return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), temp);
12748         }
12749     }
12750
12751   if (! host_integerp (size, 1))
12752     return NULL_TREE;
12753
12754   if (! integer_all_onesp (size))
12755     {
12756       if (! host_integerp (len, 1))
12757         {
12758           /* If LEN is not constant, try MAXLEN too.
12759              For MAXLEN only allow optimizing into non-_ocs function
12760              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12761           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12762             {
12763               if (fcode == BUILT_IN_MEMPCPY_CHK && ignore)
12764                 {
12765                   /* (void) __mempcpy_chk () can be optimized into
12766                      (void) __memcpy_chk ().  */
12767                   fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
12768                   if (!fn)
12769                     return NULL_TREE;
12770
12771                   return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12772                 }
12773               return NULL_TREE;
12774             }
12775         }
12776       else
12777         maxlen = len;
12778
12779       if (tree_int_cst_lt (size, maxlen))
12780         return NULL_TREE;
12781     }
12782
12783   fn = NULL_TREE;
12784   /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
12785      mem{cpy,pcpy,move,set} is available.  */
12786   switch (fcode)
12787     {
12788     case BUILT_IN_MEMCPY_CHK:
12789       fn = builtin_decl_explicit (BUILT_IN_MEMCPY);
12790       break;
12791     case BUILT_IN_MEMPCPY_CHK:
12792       fn = builtin_decl_explicit (BUILT_IN_MEMPCPY);
12793       break;
12794     case BUILT_IN_MEMMOVE_CHK:
12795       fn = builtin_decl_explicit (BUILT_IN_MEMMOVE);
12796       break;
12797     case BUILT_IN_MEMSET_CHK:
12798       fn = builtin_decl_explicit (BUILT_IN_MEMSET);
12799       break;
12800     default:
12801       break;
12802     }
12803
12804   if (!fn)
12805     return NULL_TREE;
12806
12807   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12808 }
12809
12810 /* Fold a call to the __st[rp]cpy_chk builtin.
12811    DEST, SRC, and SIZE are the arguments to the call.
12812    IGNORE is true if return value can be ignored.  FCODE is the BUILT_IN_*
12813    code of the builtin.  If MAXLEN is not NULL, it is maximum length of
12814    strings passed as second argument.  */
12815
12816 tree
12817 fold_builtin_stxcpy_chk (location_t loc, tree fndecl, tree dest,
12818                          tree src, tree size,
12819                          tree maxlen, bool ignore,
12820                          enum built_in_function fcode)
12821 {
12822   tree len, fn;
12823
12824   if (!validate_arg (dest, POINTER_TYPE)
12825       || !validate_arg (src, POINTER_TYPE)
12826       || !validate_arg (size, INTEGER_TYPE))
12827     return NULL_TREE;
12828
12829   /* If SRC and DEST are the same (and not volatile), return DEST.  */
12830   if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0))
12831     return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest);
12832
12833   if (! host_integerp (size, 1))
12834     return NULL_TREE;
12835
12836   if (! integer_all_onesp (size))
12837     {
12838       len = c_strlen (src, 1);
12839       if (! len || ! host_integerp (len, 1))
12840         {
12841           /* If LEN is not constant, try MAXLEN too.
12842              For MAXLEN only allow optimizing into non-_ocs function
12843              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12844           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12845             {
12846               if (fcode == BUILT_IN_STPCPY_CHK)
12847                 {
12848                   if (! ignore)
12849                     return NULL_TREE;
12850
12851                   /* If return value of __stpcpy_chk is ignored,
12852                      optimize into __strcpy_chk.  */
12853                   fn = builtin_decl_explicit (BUILT_IN_STRCPY_CHK);
12854                   if (!fn)
12855                     return NULL_TREE;
12856
12857                   return build_call_expr_loc (loc, fn, 3, dest, src, size);
12858                 }
12859
12860               if (! len || TREE_SIDE_EFFECTS (len))
12861                 return NULL_TREE;
12862
12863               /* If c_strlen returned something, but not a constant,
12864                  transform __strcpy_chk into __memcpy_chk.  */
12865               fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
12866               if (!fn)
12867                 return NULL_TREE;
12868
12869               len = fold_convert_loc (loc, size_type_node, len);
12870               len = size_binop_loc (loc, PLUS_EXPR, len,
12871                                     build_int_cst (size_type_node, 1));
12872               return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)),
12873                                        build_call_expr_loc (loc, fn, 4,
12874                                                         dest, src, len, size));
12875             }
12876         }
12877       else
12878         maxlen = len;
12879
12880       if (! tree_int_cst_lt (maxlen, size))
12881         return NULL_TREE;
12882     }
12883
12884   /* If __builtin_st{r,p}cpy_chk is used, assume st{r,p}cpy is available.  */
12885   fn = builtin_decl_explicit (fcode == BUILT_IN_STPCPY_CHK
12886                               ? BUILT_IN_STPCPY : BUILT_IN_STRCPY);
12887   if (!fn)
12888     return NULL_TREE;
12889
12890   return build_call_expr_loc (loc, fn, 2, dest, src);
12891 }
12892
12893 /* Fold a call to the __st{r,p}ncpy_chk builtin.  DEST, SRC, LEN, and SIZE
12894    are the arguments to the call.  If MAXLEN is not NULL, it is maximum
12895    length passed as third argument. IGNORE is true if return value can be
12896    ignored. FCODE is the BUILT_IN_* code of the builtin. */
12897
12898 tree
12899 fold_builtin_stxncpy_chk (location_t loc, tree dest, tree src,
12900                           tree len, tree size, tree maxlen, bool ignore,
12901                           enum built_in_function fcode)
12902 {
12903   tree fn;
12904
12905   if (!validate_arg (dest, POINTER_TYPE)
12906       || !validate_arg (src, POINTER_TYPE)
12907       || !validate_arg (len, INTEGER_TYPE)
12908       || !validate_arg (size, INTEGER_TYPE))
12909     return NULL_TREE;
12910
12911   if (fcode == BUILT_IN_STPNCPY_CHK && ignore)
12912     {
12913        /* If return value of __stpncpy_chk is ignored,
12914           optimize into __strncpy_chk.  */
12915        fn = builtin_decl_explicit (BUILT_IN_STRNCPY_CHK);
12916        if (fn)
12917          return build_call_expr_loc (loc, fn, 4, dest, src, len, size);
12918     }
12919
12920   if (! host_integerp (size, 1))
12921     return NULL_TREE;
12922
12923   if (! integer_all_onesp (size))
12924     {
12925       if (! host_integerp (len, 1))
12926         {
12927           /* If LEN is not constant, try MAXLEN too.
12928              For MAXLEN only allow optimizing into non-_ocs function
12929              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
12930           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
12931             return NULL_TREE;
12932         }
12933       else
12934         maxlen = len;
12935
12936       if (tree_int_cst_lt (size, maxlen))
12937         return NULL_TREE;
12938     }
12939
12940   /* If __builtin_st{r,p}ncpy_chk is used, assume st{r,p}ncpy is available.  */
12941   fn = builtin_decl_explicit (fcode == BUILT_IN_STPNCPY_CHK
12942                               ? BUILT_IN_STPNCPY : BUILT_IN_STRNCPY);
12943   if (!fn)
12944     return NULL_TREE;
12945
12946   return build_call_expr_loc (loc, fn, 3, dest, src, len);
12947 }
12948
12949 /* Fold a call to the __strcat_chk builtin FNDECL.  DEST, SRC, and SIZE
12950    are the arguments to the call.  */
12951
12952 static tree
12953 fold_builtin_strcat_chk (location_t loc, tree fndecl, tree dest,
12954                          tree src, tree size)
12955 {
12956   tree fn;
12957   const char *p;
12958
12959   if (!validate_arg (dest, POINTER_TYPE)
12960       || !validate_arg (src, POINTER_TYPE)
12961       || !validate_arg (size, INTEGER_TYPE))
12962     return NULL_TREE;
12963
12964   p = c_getstr (src);
12965   /* If the SRC parameter is "", return DEST.  */
12966   if (p && *p == '\0')
12967     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
12968
12969   if (! host_integerp (size, 1) || ! integer_all_onesp (size))
12970     return NULL_TREE;
12971
12972   /* If __builtin_strcat_chk is used, assume strcat is available.  */
12973   fn = builtin_decl_explicit (BUILT_IN_STRCAT);
12974   if (!fn)
12975     return NULL_TREE;
12976
12977   return build_call_expr_loc (loc, fn, 2, dest, src);
12978 }
12979
12980 /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC,
12981    LEN, and SIZE.  */
12982
12983 static tree
12984 fold_builtin_strncat_chk (location_t loc, tree fndecl,
12985                           tree dest, tree src, tree len, tree size)
12986 {
12987   tree fn;
12988   const char *p;
12989
12990   if (!validate_arg (dest, POINTER_TYPE)
12991       || !validate_arg (src, POINTER_TYPE)
12992       || !validate_arg (size, INTEGER_TYPE)
12993       || !validate_arg (size, INTEGER_TYPE))
12994     return NULL_TREE;
12995
12996   p = c_getstr (src);
12997   /* If the SRC parameter is "" or if LEN is 0, return DEST.  */
12998   if (p && *p == '\0')
12999     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, len);
13000   else if (integer_zerop (len))
13001     return omit_one_operand_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), dest, src);
13002
13003   if (! host_integerp (size, 1))
13004     return NULL_TREE;
13005
13006   if (! integer_all_onesp (size))
13007     {
13008       tree src_len = c_strlen (src, 1);
13009       if (src_len
13010           && host_integerp (src_len, 1)
13011           && host_integerp (len, 1)
13012           && ! tree_int_cst_lt (len, src_len))
13013         {
13014           /* If LEN >= strlen (SRC), optimize into __strcat_chk.  */
13015           fn = builtin_decl_explicit (BUILT_IN_STRCAT_CHK);
13016           if (!fn)
13017             return NULL_TREE;
13018
13019           return build_call_expr_loc (loc, fn, 3, dest, src, size);
13020         }
13021       return NULL_TREE;
13022     }
13023
13024   /* If __builtin_strncat_chk is used, assume strncat is available.  */
13025   fn = builtin_decl_explicit (BUILT_IN_STRNCAT);
13026   if (!fn)
13027     return NULL_TREE;
13028
13029   return build_call_expr_loc (loc, fn, 3, dest, src, len);
13030 }
13031
13032 /* Fold a call EXP to __{,v}sprintf_chk having NARGS passed as ARGS.
13033    Return NULL_TREE if a normal call should be emitted rather than
13034    expanding the function inline.  FCODE is either BUILT_IN_SPRINTF_CHK
13035    or BUILT_IN_VSPRINTF_CHK.  */
13036
13037 static tree
13038 fold_builtin_sprintf_chk_1 (location_t loc, int nargs, tree *args,
13039                             enum built_in_function fcode)
13040 {
13041   tree dest, size, len, fn, fmt, flag;
13042   const char *fmt_str;
13043
13044   /* Verify the required arguments in the original call.  */
13045   if (nargs < 4)
13046     return NULL_TREE;
13047   dest = args[0];
13048   if (!validate_arg (dest, POINTER_TYPE))
13049     return NULL_TREE;
13050   flag = args[1];
13051   if (!validate_arg (flag, INTEGER_TYPE))
13052     return NULL_TREE;
13053   size = args[2];
13054   if (!validate_arg (size, INTEGER_TYPE))
13055     return NULL_TREE;
13056   fmt = args[3];
13057   if (!validate_arg (fmt, POINTER_TYPE))
13058     return NULL_TREE;
13059
13060   if (! host_integerp (size, 1))
13061     return NULL_TREE;
13062
13063   len = NULL_TREE;
13064
13065   if (!init_target_chars ())
13066     return NULL_TREE;
13067
13068   /* Check whether the format is a literal string constant.  */
13069   fmt_str = c_getstr (fmt);
13070   if (fmt_str != NULL)
13071     {
13072       /* If the format doesn't contain % args or %%, we know the size.  */
13073       if (strchr (fmt_str, target_percent) == 0)
13074         {
13075           if (fcode != BUILT_IN_SPRINTF_CHK || nargs == 4)
13076             len = build_int_cstu (size_type_node, strlen (fmt_str));
13077         }
13078       /* If the format is "%s" and first ... argument is a string literal,
13079          we know the size too.  */
13080       else if (fcode == BUILT_IN_SPRINTF_CHK
13081                && strcmp (fmt_str, target_percent_s) == 0)
13082         {
13083           tree arg;
13084
13085           if (nargs == 5)
13086             {
13087               arg = args[4];
13088               if (validate_arg (arg, POINTER_TYPE))
13089                 {
13090                   len = c_strlen (arg, 1);
13091                   if (! len || ! host_integerp (len, 1))
13092                     len = NULL_TREE;
13093                 }
13094             }
13095         }
13096     }
13097
13098   if (! integer_all_onesp (size))
13099     {
13100       if (! len || ! tree_int_cst_lt (len, size))
13101         return NULL_TREE;
13102     }
13103
13104   /* Only convert __{,v}sprintf_chk to {,v}sprintf if flag is 0
13105      or if format doesn't contain % chars or is "%s".  */
13106   if (! integer_zerop (flag))
13107     {
13108       if (fmt_str == NULL)
13109         return NULL_TREE;
13110       if (strchr (fmt_str, target_percent) != NULL
13111           && strcmp (fmt_str, target_percent_s))
13112         return NULL_TREE;
13113     }
13114
13115   /* If __builtin_{,v}sprintf_chk is used, assume {,v}sprintf is available.  */
13116   fn = builtin_decl_explicit (fcode == BUILT_IN_VSPRINTF_CHK
13117                               ? BUILT_IN_VSPRINTF : BUILT_IN_SPRINTF);
13118   if (!fn)
13119     return NULL_TREE;
13120
13121   return rewrite_call_expr_array (loc, nargs, args, 4, fn, 2, dest, fmt);
13122 }
13123
13124 /* Fold a call EXP to __{,v}sprintf_chk.  Return NULL_TREE if
13125    a normal call should be emitted rather than expanding the function
13126    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
13127
13128 static tree
13129 fold_builtin_sprintf_chk (location_t loc, tree exp,
13130                           enum built_in_function fcode)
13131 {
13132   return fold_builtin_sprintf_chk_1 (loc, call_expr_nargs (exp),
13133                                      CALL_EXPR_ARGP (exp), fcode);
13134 }
13135
13136 /* Fold a call EXP to {,v}snprintf having NARGS passed as ARGS.  Return
13137    NULL_TREE if a normal call should be emitted rather than expanding
13138    the function inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
13139    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
13140    passed as second argument.  */
13141
13142 static tree
13143 fold_builtin_snprintf_chk_1 (location_t loc, int nargs, tree *args,
13144                              tree maxlen, enum built_in_function fcode)
13145 {
13146   tree dest, size, len, fn, fmt, flag;
13147   const char *fmt_str;
13148
13149   /* Verify the required arguments in the original call.  */
13150   if (nargs < 5)
13151     return NULL_TREE;
13152   dest = args[0];
13153   if (!validate_arg (dest, POINTER_TYPE))
13154     return NULL_TREE;
13155   len = args[1];
13156   if (!validate_arg (len, INTEGER_TYPE))
13157     return NULL_TREE;
13158   flag = args[2];
13159   if (!validate_arg (flag, INTEGER_TYPE))
13160     return NULL_TREE;
13161   size = args[3];
13162   if (!validate_arg (size, INTEGER_TYPE))
13163     return NULL_TREE;
13164   fmt = args[4];
13165   if (!validate_arg (fmt, POINTER_TYPE))
13166     return NULL_TREE;
13167
13168   if (! host_integerp (size, 1))
13169     return NULL_TREE;
13170
13171   if (! integer_all_onesp (size))
13172     {
13173       if (! host_integerp (len, 1))
13174         {
13175           /* If LEN is not constant, try MAXLEN too.
13176              For MAXLEN only allow optimizing into non-_ocs function
13177              if SIZE is >= MAXLEN, never convert to __ocs_fail ().  */
13178           if (maxlen == NULL_TREE || ! host_integerp (maxlen, 1))
13179             return NULL_TREE;
13180         }
13181       else
13182         maxlen = len;
13183
13184       if (tree_int_cst_lt (size, maxlen))
13185         return NULL_TREE;
13186     }
13187
13188   if (!init_target_chars ())
13189     return NULL_TREE;
13190
13191   /* Only convert __{,v}snprintf_chk to {,v}snprintf if flag is 0
13192      or if format doesn't contain % chars or is "%s".  */
13193   if (! integer_zerop (flag))
13194     {
13195       fmt_str = c_getstr (fmt);
13196       if (fmt_str == NULL)
13197         return NULL_TREE;
13198       if (strchr (fmt_str, target_percent) != NULL
13199           && strcmp (fmt_str, target_percent_s))
13200         return NULL_TREE;
13201     }
13202
13203   /* If __builtin_{,v}snprintf_chk is used, assume {,v}snprintf is
13204      available.  */
13205   fn = builtin_decl_explicit (fcode == BUILT_IN_VSNPRINTF_CHK
13206                               ? BUILT_IN_VSNPRINTF : BUILT_IN_SNPRINTF);
13207   if (!fn)
13208     return NULL_TREE;
13209
13210   return rewrite_call_expr_array (loc, nargs, args, 5, fn, 3, dest, len, fmt);
13211 }
13212
13213 /* Fold a call EXP to {,v}snprintf.  Return NULL_TREE if
13214    a normal call should be emitted rather than expanding the function
13215    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
13216    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
13217    passed as second argument.  */
13218
13219 tree
13220 fold_builtin_snprintf_chk (location_t loc, tree exp, tree maxlen,
13221                            enum built_in_function fcode)
13222 {
13223   return fold_builtin_snprintf_chk_1 (loc, call_expr_nargs (exp),
13224                                       CALL_EXPR_ARGP (exp), maxlen, fcode);
13225 }
13226
13227 /* Fold a call to the {,v}printf{,_unlocked} and __{,v}printf_chk builtins.
13228    FMT and ARG are the arguments to the call; we don't fold cases with
13229    more than 2 arguments, and ARG may be null if this is a 1-argument case.
13230
13231    Return NULL_TREE if no simplification was possible, otherwise return the
13232    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
13233    code of the function to be simplified.  */
13234
13235 static tree
13236 fold_builtin_printf (location_t loc, tree fndecl, tree fmt,
13237                      tree arg, bool ignore,
13238                      enum built_in_function fcode)
13239 {
13240   tree fn_putchar, fn_puts, newarg, call = NULL_TREE;
13241   const char *fmt_str = NULL;
13242
13243   /* If the return value is used, don't do the transformation.  */
13244   if (! ignore)
13245     return NULL_TREE;
13246
13247   /* Verify the required arguments in the original call.  */
13248   if (!validate_arg (fmt, POINTER_TYPE))
13249     return NULL_TREE;
13250
13251   /* Check whether the format is a literal string constant.  */
13252   fmt_str = c_getstr (fmt);
13253   if (fmt_str == NULL)
13254     return NULL_TREE;
13255
13256   if (fcode == BUILT_IN_PRINTF_UNLOCKED)
13257     {
13258       /* If we're using an unlocked function, assume the other
13259          unlocked functions exist explicitly.  */
13260       fn_putchar = builtin_decl_explicit (BUILT_IN_PUTCHAR_UNLOCKED);
13261       fn_puts = builtin_decl_explicit (BUILT_IN_PUTS_UNLOCKED);
13262     }
13263   else
13264     {
13265       fn_putchar = builtin_decl_implicit (BUILT_IN_PUTCHAR);
13266       fn_puts = builtin_decl_implicit (BUILT_IN_PUTS);
13267     }
13268
13269   if (!init_target_chars ())
13270     return NULL_TREE;
13271
13272   if (strcmp (fmt_str, target_percent_s) == 0
13273       || strchr (fmt_str, target_percent) == NULL)
13274     {
13275       const char *str;
13276
13277       if (strcmp (fmt_str, target_percent_s) == 0)
13278         {
13279           if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
13280             return NULL_TREE;
13281
13282           if (!arg || !validate_arg (arg, POINTER_TYPE))
13283             return NULL_TREE;
13284
13285           str = c_getstr (arg);
13286           if (str == NULL)
13287             return NULL_TREE;
13288         }
13289       else
13290         {
13291           /* The format specifier doesn't contain any '%' characters.  */
13292           if (fcode != BUILT_IN_VPRINTF && fcode != BUILT_IN_VPRINTF_CHK
13293               && arg)
13294             return NULL_TREE;
13295           str = fmt_str;
13296         }
13297
13298       /* If the string was "", printf does nothing.  */
13299       if (str[0] == '\0')
13300         return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
13301
13302       /* If the string has length of 1, call putchar.  */
13303       if (str[1] == '\0')
13304         {
13305           /* Given printf("c"), (where c is any one character,)
13306              convert "c"[0] to an int and pass that to the replacement
13307              function.  */
13308           newarg = build_int_cst (integer_type_node, str[0]);
13309           if (fn_putchar)
13310             call = build_call_expr_loc (loc, fn_putchar, 1, newarg);
13311         }
13312       else
13313         {
13314           /* If the string was "string\n", call puts("string").  */
13315           size_t len = strlen (str);
13316           if ((unsigned char)str[len - 1] == target_newline
13317               && (size_t) (int) len == len
13318               && (int) len > 0)
13319             {
13320               char *newstr;
13321               tree offset_node, string_cst;
13322
13323               /* Create a NUL-terminated string that's one char shorter
13324                  than the original, stripping off the trailing '\n'.  */
13325               newarg = build_string_literal (len, str);
13326               string_cst = string_constant (newarg, &offset_node);
13327               gcc_checking_assert (string_cst
13328                                    && (TREE_STRING_LENGTH (string_cst)
13329                                        == (int) len)
13330                                    && integer_zerop (offset_node)
13331                                    && (unsigned char)
13332                                       TREE_STRING_POINTER (string_cst)[len - 1]
13333                                       == target_newline);
13334               /* build_string_literal creates a new STRING_CST,
13335                  modify it in place to avoid double copying.  */
13336               newstr = CONST_CAST (char *, TREE_STRING_POINTER (string_cst));
13337               newstr[len - 1] = '\0';
13338               if (fn_puts)
13339                 call = build_call_expr_loc (loc, fn_puts, 1, newarg);
13340             }
13341           else
13342             /* We'd like to arrange to call fputs(string,stdout) here,
13343                but we need stdout and don't have a way to get it yet.  */
13344             return NULL_TREE;
13345         }
13346     }
13347
13348   /* The other optimizations can be done only on the non-va_list variants.  */
13349   else if (fcode == BUILT_IN_VPRINTF || fcode == BUILT_IN_VPRINTF_CHK)
13350     return NULL_TREE;
13351
13352   /* If the format specifier was "%s\n", call __builtin_puts(arg).  */
13353   else if (strcmp (fmt_str, target_percent_s_newline) == 0)
13354     {
13355       if (!arg || !validate_arg (arg, POINTER_TYPE))
13356         return NULL_TREE;
13357       if (fn_puts)
13358         call = build_call_expr_loc (loc, fn_puts, 1, arg);
13359     }
13360
13361   /* If the format specifier was "%c", call __builtin_putchar(arg).  */
13362   else if (strcmp (fmt_str, target_percent_c) == 0)
13363     {
13364       if (!arg || !validate_arg (arg, INTEGER_TYPE))
13365         return NULL_TREE;
13366       if (fn_putchar)
13367         call = build_call_expr_loc (loc, fn_putchar, 1, arg);
13368     }
13369
13370   if (!call)
13371     return NULL_TREE;
13372
13373   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
13374 }
13375
13376 /* Fold a call to the {,v}fprintf{,_unlocked} and __{,v}printf_chk builtins.
13377    FP, FMT, and ARG are the arguments to the call.  We don't fold calls with
13378    more than 3 arguments, and ARG may be null in the 2-argument case.
13379
13380    Return NULL_TREE if no simplification was possible, otherwise return the
13381    simplified form of the call as a tree.  FCODE is the BUILT_IN_*
13382    code of the function to be simplified.  */
13383
13384 static tree
13385 fold_builtin_fprintf (location_t loc, tree fndecl, tree fp,
13386                       tree fmt, tree arg, bool ignore,
13387                       enum built_in_function fcode)
13388 {
13389   tree fn_fputc, fn_fputs, call = NULL_TREE;
13390   const char *fmt_str = NULL;
13391
13392   /* If the return value is used, don't do the transformation.  */
13393   if (! ignore)
13394     return NULL_TREE;
13395
13396   /* Verify the required arguments in the original call.  */
13397   if (!validate_arg (fp, POINTER_TYPE))
13398     return NULL_TREE;
13399   if (!validate_arg (fmt, POINTER_TYPE))
13400     return NULL_TREE;
13401
13402   /* Check whether the format is a literal string constant.  */
13403   fmt_str = c_getstr (fmt);
13404   if (fmt_str == NULL)
13405     return NULL_TREE;
13406
13407   if (fcode == BUILT_IN_FPRINTF_UNLOCKED)
13408     {
13409       /* If we're using an unlocked function, assume the other
13410          unlocked functions exist explicitly.  */
13411       fn_fputc = builtin_decl_explicit (BUILT_IN_FPUTC_UNLOCKED);
13412       fn_fputs = builtin_decl_explicit (BUILT_IN_FPUTS_UNLOCKED);
13413     }
13414   else
13415     {
13416       fn_fputc = builtin_decl_implicit (BUILT_IN_FPUTC);
13417       fn_fputs = builtin_decl_implicit (BUILT_IN_FPUTS);
13418     }
13419
13420   if (!init_target_chars ())
13421     return NULL_TREE;
13422
13423   /* If the format doesn't contain % args or %%, use strcpy.  */
13424   if (strchr (fmt_str, target_percent) == NULL)
13425     {
13426       if (fcode != BUILT_IN_VFPRINTF && fcode != BUILT_IN_VFPRINTF_CHK
13427           && arg)
13428         return NULL_TREE;
13429
13430       /* If the format specifier was "", fprintf does nothing.  */
13431       if (fmt_str[0] == '\0')
13432         {
13433           /* If FP has side-effects, just wait until gimplification is
13434              done.  */
13435           if (TREE_SIDE_EFFECTS (fp))
13436             return NULL_TREE;
13437
13438           return build_int_cst (TREE_TYPE (TREE_TYPE (fndecl)), 0);
13439         }
13440
13441       /* When "string" doesn't contain %, replace all cases of
13442          fprintf (fp, string) with fputs (string, fp).  The fputs
13443          builtin will take care of special cases like length == 1.  */
13444       if (fn_fputs)
13445         call = build_call_expr_loc (loc, fn_fputs, 2, fmt, fp);
13446     }
13447
13448   /* The other optimizations can be done only on the non-va_list variants.  */
13449   else if (fcode == BUILT_IN_VFPRINTF || fcode == BUILT_IN_VFPRINTF_CHK)
13450     return NULL_TREE;
13451
13452   /* If the format specifier was "%s", call __builtin_fputs (arg, fp).  */
13453   else if (strcmp (fmt_str, target_percent_s) == 0)
13454     {
13455       if (!arg || !validate_arg (arg, POINTER_TYPE))
13456         return NULL_TREE;
13457       if (fn_fputs)
13458         call = build_call_expr_loc (loc, fn_fputs, 2, arg, fp);
13459     }
13460
13461   /* If the format specifier was "%c", call __builtin_fputc (arg, fp).  */
13462   else if (strcmp (fmt_str, target_percent_c) == 0)
13463     {
13464       if (!arg || !validate_arg (arg, INTEGER_TYPE))
13465         return NULL_TREE;
13466       if (fn_fputc)
13467         call = build_call_expr_loc (loc, fn_fputc, 2, arg, fp);
13468     }
13469
13470   if (!call)
13471     return NULL_TREE;
13472   return fold_convert_loc (loc, TREE_TYPE (TREE_TYPE (fndecl)), call);
13473 }
13474
13475 /* Initialize format string characters in the target charset.  */
13476
13477 static bool
13478 init_target_chars (void)
13479 {
13480   static bool init;
13481   if (!init)
13482     {
13483       target_newline = lang_hooks.to_target_charset ('\n');
13484       target_percent = lang_hooks.to_target_charset ('%');
13485       target_c = lang_hooks.to_target_charset ('c');
13486       target_s = lang_hooks.to_target_charset ('s');
13487       if (target_newline == 0 || target_percent == 0 || target_c == 0
13488           || target_s == 0)
13489         return false;
13490
13491       target_percent_c[0] = target_percent;
13492       target_percent_c[1] = target_c;
13493       target_percent_c[2] = '\0';
13494
13495       target_percent_s[0] = target_percent;
13496       target_percent_s[1] = target_s;
13497       target_percent_s[2] = '\0';
13498
13499       target_percent_s_newline[0] = target_percent;
13500       target_percent_s_newline[1] = target_s;
13501       target_percent_s_newline[2] = target_newline;
13502       target_percent_s_newline[3] = '\0';
13503
13504       init = true;
13505     }
13506   return true;
13507 }
13508
13509 /* Helper function for do_mpfr_arg*().  Ensure M is a normal number
13510    and no overflow/underflow occurred.  INEXACT is true if M was not
13511    exactly calculated.  TYPE is the tree type for the result.  This
13512    function assumes that you cleared the MPFR flags and then
13513    calculated M to see if anything subsequently set a flag prior to
13514    entering this function.  Return NULL_TREE if any checks fail.  */
13515
13516 static tree
13517 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
13518 {
13519   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13520      overflow/underflow occurred.  If -frounding-math, proceed iff the
13521      result of calling FUNC was exact.  */
13522   if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
13523       && (!flag_rounding_math || !inexact))
13524     {
13525       REAL_VALUE_TYPE rr;
13526
13527       real_from_mpfr (&rr, m, type, GMP_RNDN);
13528       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
13529          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
13530          but the mpft_t is not, then we underflowed in the
13531          conversion.  */
13532       if (real_isfinite (&rr)
13533           && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
13534         {
13535           REAL_VALUE_TYPE rmode;
13536
13537           real_convert (&rmode, TYPE_MODE (type), &rr);
13538           /* Proceed iff the specified mode can hold the value.  */
13539           if (real_identical (&rmode, &rr))
13540             return build_real (type, rmode);
13541         }
13542     }
13543   return NULL_TREE;
13544 }
13545
13546 /* Helper function for do_mpc_arg*().  Ensure M is a normal complex
13547    number and no overflow/underflow occurred.  INEXACT is true if M
13548    was not exactly calculated.  TYPE is the tree type for the result.
13549    This function assumes that you cleared the MPFR flags and then
13550    calculated M to see if anything subsequently set a flag prior to
13551    entering this function.  Return NULL_TREE if any checks fail, if
13552    FORCE_CONVERT is true, then bypass the checks.  */
13553
13554 static tree
13555 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
13556 {
13557   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
13558      overflow/underflow occurred.  If -frounding-math, proceed iff the
13559      result of calling FUNC was exact.  */
13560   if (force_convert
13561       || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
13562           && !mpfr_overflow_p () && !mpfr_underflow_p ()
13563           && (!flag_rounding_math || !inexact)))
13564     {
13565       REAL_VALUE_TYPE re, im;
13566
13567       real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
13568       real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
13569       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
13570          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
13571          but the mpft_t is not, then we underflowed in the
13572          conversion.  */
13573       if (force_convert
13574           || (real_isfinite (&re) && real_isfinite (&im)
13575               && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
13576               && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
13577         {
13578           REAL_VALUE_TYPE re_mode, im_mode;
13579
13580           real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
13581           real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
13582           /* Proceed iff the specified mode can hold the value.  */
13583           if (force_convert
13584               || (real_identical (&re_mode, &re)
13585                   && real_identical (&im_mode, &im)))
13586             return build_complex (type, build_real (TREE_TYPE (type), re_mode),
13587                                   build_real (TREE_TYPE (type), im_mode));
13588         }
13589     }
13590   return NULL_TREE;
13591 }
13592
13593 /* If argument ARG is a REAL_CST, call the one-argument mpfr function
13594    FUNC on it and return the resulting value as a tree with type TYPE.
13595    If MIN and/or MAX are not NULL, then the supplied ARG must be
13596    within those bounds.  If INCLUSIVE is true, then MIN/MAX are
13597    acceptable values, otherwise they are not.  The mpfr precision is
13598    set to the precision of TYPE.  We assume that function FUNC returns
13599    zero if the result could be calculated exactly within the requested
13600    precision.  */
13601
13602 static tree
13603 do_mpfr_arg1 (tree arg, tree type, int (*func)(mpfr_ptr, mpfr_srcptr, mp_rnd_t),
13604               const REAL_VALUE_TYPE *min, const REAL_VALUE_TYPE *max,
13605               bool inclusive)
13606 {
13607   tree result = NULL_TREE;
13608
13609   STRIP_NOPS (arg);
13610
13611   /* To proceed, MPFR must exactly represent the target floating point
13612      format, which only happens when the target base equals two.  */
13613   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13614       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg))
13615     {
13616       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13617
13618       if (real_isfinite (ra)
13619           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min))
13620           && (!max || real_compare (inclusive ? LE_EXPR: LT_EXPR , ra, max)))
13621         {
13622           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13623           const int prec = fmt->p;
13624           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13625           int inexact;
13626           mpfr_t m;
13627
13628           mpfr_init2 (m, prec);
13629           mpfr_from_real (m, ra, GMP_RNDN);
13630           mpfr_clear_flags ();
13631           inexact = func (m, m, rnd);
13632           result = do_mpfr_ckconv (m, type, inexact);
13633           mpfr_clear (m);
13634         }
13635     }
13636
13637   return result;
13638 }
13639
13640 /* If argument ARG is a REAL_CST, call the two-argument mpfr function
13641    FUNC on it and return the resulting value as a tree with type TYPE.
13642    The mpfr precision is set to the precision of TYPE.  We assume that
13643    function FUNC returns zero if the result could be calculated
13644    exactly within the requested precision.  */
13645
13646 static tree
13647 do_mpfr_arg2 (tree arg1, tree arg2, tree type,
13648               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13649 {
13650   tree result = NULL_TREE;
13651
13652   STRIP_NOPS (arg1);
13653   STRIP_NOPS (arg2);
13654
13655   /* To proceed, MPFR must exactly represent the target floating point
13656      format, which only happens when the target base equals two.  */
13657   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13658       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13659       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13660     {
13661       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13662       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13663
13664       if (real_isfinite (ra1) && real_isfinite (ra2))
13665         {
13666           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13667           const int prec = fmt->p;
13668           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13669           int inexact;
13670           mpfr_t m1, m2;
13671
13672           mpfr_inits2 (prec, m1, m2, NULL);
13673           mpfr_from_real (m1, ra1, GMP_RNDN);
13674           mpfr_from_real (m2, ra2, GMP_RNDN);
13675           mpfr_clear_flags ();
13676           inexact = func (m1, m1, m2, rnd);
13677           result = do_mpfr_ckconv (m1, type, inexact);
13678           mpfr_clears (m1, m2, NULL);
13679         }
13680     }
13681
13682   return result;
13683 }
13684
13685 /* If argument ARG is a REAL_CST, call the three-argument mpfr function
13686    FUNC on it and return the resulting value as a tree with type TYPE.
13687    The mpfr precision is set to the precision of TYPE.  We assume that
13688    function FUNC returns zero if the result could be calculated
13689    exactly within the requested precision.  */
13690
13691 static tree
13692 do_mpfr_arg3 (tree arg1, tree arg2, tree arg3, tree type,
13693               int (*func)(mpfr_ptr, mpfr_srcptr, mpfr_srcptr, mpfr_srcptr, mp_rnd_t))
13694 {
13695   tree result = NULL_TREE;
13696
13697   STRIP_NOPS (arg1);
13698   STRIP_NOPS (arg2);
13699   STRIP_NOPS (arg3);
13700
13701   /* To proceed, MPFR must exactly represent the target floating point
13702      format, which only happens when the target base equals two.  */
13703   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13704       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1)
13705       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)
13706       && TREE_CODE (arg3) == REAL_CST && !TREE_OVERFLOW (arg3))
13707     {
13708       const REAL_VALUE_TYPE *const ra1 = &TREE_REAL_CST (arg1);
13709       const REAL_VALUE_TYPE *const ra2 = &TREE_REAL_CST (arg2);
13710       const REAL_VALUE_TYPE *const ra3 = &TREE_REAL_CST (arg3);
13711
13712       if (real_isfinite (ra1) && real_isfinite (ra2) && real_isfinite (ra3))
13713         {
13714           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13715           const int prec = fmt->p;
13716           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13717           int inexact;
13718           mpfr_t m1, m2, m3;
13719
13720           mpfr_inits2 (prec, m1, m2, m3, NULL);
13721           mpfr_from_real (m1, ra1, GMP_RNDN);
13722           mpfr_from_real (m2, ra2, GMP_RNDN);
13723           mpfr_from_real (m3, ra3, GMP_RNDN);
13724           mpfr_clear_flags ();
13725           inexact = func (m1, m1, m2, m3, rnd);
13726           result = do_mpfr_ckconv (m1, type, inexact);
13727           mpfr_clears (m1, m2, m3, NULL);
13728         }
13729     }
13730
13731   return result;
13732 }
13733
13734 /* If argument ARG is a REAL_CST, call mpfr_sin_cos() on it and set
13735    the pointers *(ARG_SINP) and *(ARG_COSP) to the resulting values.
13736    If ARG_SINP and ARG_COSP are NULL then the result is returned
13737    as a complex value.
13738    The type is taken from the type of ARG and is used for setting the
13739    precision of the calculation and results.  */
13740
13741 static tree
13742 do_mpfr_sincos (tree arg, tree arg_sinp, tree arg_cosp)
13743 {
13744   tree const type = TREE_TYPE (arg);
13745   tree result = NULL_TREE;
13746
13747   STRIP_NOPS (arg);
13748
13749   /* To proceed, MPFR must exactly represent the target floating point
13750      format, which only happens when the target base equals two.  */
13751   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13752       && TREE_CODE (arg) == REAL_CST
13753       && !TREE_OVERFLOW (arg))
13754     {
13755       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg);
13756
13757       if (real_isfinite (ra))
13758         {
13759           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13760           const int prec = fmt->p;
13761           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13762           tree result_s, result_c;
13763           int inexact;
13764           mpfr_t m, ms, mc;
13765
13766           mpfr_inits2 (prec, m, ms, mc, NULL);
13767           mpfr_from_real (m, ra, GMP_RNDN);
13768           mpfr_clear_flags ();
13769           inexact = mpfr_sin_cos (ms, mc, m, rnd);
13770           result_s = do_mpfr_ckconv (ms, type, inexact);
13771           result_c = do_mpfr_ckconv (mc, type, inexact);
13772           mpfr_clears (m, ms, mc, NULL);
13773           if (result_s && result_c)
13774             {
13775               /* If we are to return in a complex value do so.  */
13776               if (!arg_sinp && !arg_cosp)
13777                 return build_complex (build_complex_type (type),
13778                                       result_c, result_s);
13779
13780               /* Dereference the sin/cos pointer arguments.  */
13781               arg_sinp = build_fold_indirect_ref (arg_sinp);
13782               arg_cosp = build_fold_indirect_ref (arg_cosp);
13783               /* Proceed if valid pointer type were passed in.  */
13784               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_sinp)) == TYPE_MAIN_VARIANT (type)
13785                   && TYPE_MAIN_VARIANT (TREE_TYPE (arg_cosp)) == TYPE_MAIN_VARIANT (type))
13786                 {
13787                   /* Set the values. */
13788                   result_s = fold_build2 (MODIFY_EXPR, type, arg_sinp,
13789                                           result_s);
13790                   TREE_SIDE_EFFECTS (result_s) = 1;
13791                   result_c = fold_build2 (MODIFY_EXPR, type, arg_cosp,
13792                                           result_c);
13793                   TREE_SIDE_EFFECTS (result_c) = 1;
13794                   /* Combine the assignments into a compound expr.  */
13795                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13796                                                     result_s, result_c));
13797                 }
13798             }
13799         }
13800     }
13801   return result;
13802 }
13803
13804 /* If argument ARG1 is an INTEGER_CST and ARG2 is a REAL_CST, call the
13805    two-argument mpfr order N Bessel function FUNC on them and return
13806    the resulting value as a tree with type TYPE.  The mpfr precision
13807    is set to the precision of TYPE.  We assume that function FUNC
13808    returns zero if the result could be calculated exactly within the
13809    requested precision.  */
13810 static tree
13811 do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
13812                   int (*func)(mpfr_ptr, long, mpfr_srcptr, mp_rnd_t),
13813                   const REAL_VALUE_TYPE *min, bool inclusive)
13814 {
13815   tree result = NULL_TREE;
13816
13817   STRIP_NOPS (arg1);
13818   STRIP_NOPS (arg2);
13819
13820   /* To proceed, MPFR must exactly represent the target floating point
13821      format, which only happens when the target base equals two.  */
13822   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13823       && host_integerp (arg1, 0)
13824       && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
13825     {
13826       const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
13827       const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
13828
13829       if (n == (long)n
13830           && real_isfinite (ra)
13831           && (!min || real_compare (inclusive ? GE_EXPR: GT_EXPR , ra, min)))
13832         {
13833           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13834           const int prec = fmt->p;
13835           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13836           int inexact;
13837           mpfr_t m;
13838
13839           mpfr_init2 (m, prec);
13840           mpfr_from_real (m, ra, GMP_RNDN);
13841           mpfr_clear_flags ();
13842           inexact = func (m, n, m, rnd);
13843           result = do_mpfr_ckconv (m, type, inexact);
13844           mpfr_clear (m);
13845         }
13846     }
13847
13848   return result;
13849 }
13850
13851 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
13852    the pointer *(ARG_QUO) and return the result.  The type is taken
13853    from the type of ARG0 and is used for setting the precision of the
13854    calculation and results.  */
13855
13856 static tree
13857 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
13858 {
13859   tree const type = TREE_TYPE (arg0);
13860   tree result = NULL_TREE;
13861
13862   STRIP_NOPS (arg0);
13863   STRIP_NOPS (arg1);
13864
13865   /* To proceed, MPFR must exactly represent the target floating point
13866      format, which only happens when the target base equals two.  */
13867   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13868       && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
13869       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
13870     {
13871       const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
13872       const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
13873
13874       if (real_isfinite (ra0) && real_isfinite (ra1))
13875         {
13876           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13877           const int prec = fmt->p;
13878           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13879           tree result_rem;
13880           long integer_quo;
13881           mpfr_t m0, m1;
13882
13883           mpfr_inits2 (prec, m0, m1, NULL);
13884           mpfr_from_real (m0, ra0, GMP_RNDN);
13885           mpfr_from_real (m1, ra1, GMP_RNDN);
13886           mpfr_clear_flags ();
13887           mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
13888           /* Remquo is independent of the rounding mode, so pass
13889              inexact=0 to do_mpfr_ckconv().  */
13890           result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
13891           mpfr_clears (m0, m1, NULL);
13892           if (result_rem)
13893             {
13894               /* MPFR calculates quo in the host's long so it may
13895                  return more bits in quo than the target int can hold
13896                  if sizeof(host long) > sizeof(target int).  This can
13897                  happen even for native compilers in LP64 mode.  In
13898                  these cases, modulo the quo value with the largest
13899                  number that the target int can hold while leaving one
13900                  bit for the sign.  */
13901               if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
13902                 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
13903
13904               /* Dereference the quo pointer argument.  */
13905               arg_quo = build_fold_indirect_ref (arg_quo);
13906               /* Proceed iff a valid pointer type was passed in.  */
13907               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
13908                 {
13909                   /* Set the value. */
13910                   tree result_quo
13911                     = fold_build2 (MODIFY_EXPR, TREE_TYPE (arg_quo), arg_quo,
13912                                    build_int_cst (TREE_TYPE (arg_quo),
13913                                                   integer_quo));
13914                   TREE_SIDE_EFFECTS (result_quo) = 1;
13915                   /* Combine the quo assignment with the rem.  */
13916                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13917                                                     result_quo, result_rem));
13918                 }
13919             }
13920         }
13921     }
13922   return result;
13923 }
13924
13925 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
13926    resulting value as a tree with type TYPE.  The mpfr precision is
13927    set to the precision of TYPE.  We assume that this mpfr function
13928    returns zero if the result could be calculated exactly within the
13929    requested precision.  In addition, the integer pointer represented
13930    by ARG_SG will be dereferenced and set to the appropriate signgam
13931    (-1,1) value.  */
13932
13933 static tree
13934 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
13935 {
13936   tree result = NULL_TREE;
13937
13938   STRIP_NOPS (arg);
13939
13940   /* To proceed, MPFR must exactly represent the target floating point
13941      format, which only happens when the target base equals two.  Also
13942      verify ARG is a constant and that ARG_SG is an int pointer.  */
13943   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
13944       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
13945       && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
13946       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
13947     {
13948       const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
13949
13950       /* In addition to NaN and Inf, the argument cannot be zero or a
13951          negative integer.  */
13952       if (real_isfinite (ra)
13953           && ra->cl != rvc_zero
13954           && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
13955         {
13956           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
13957           const int prec = fmt->p;
13958           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
13959           int inexact, sg;
13960           mpfr_t m;
13961           tree result_lg;
13962
13963           mpfr_init2 (m, prec);
13964           mpfr_from_real (m, ra, GMP_RNDN);
13965           mpfr_clear_flags ();
13966           inexact = mpfr_lgamma (m, &sg, m, rnd);
13967           result_lg = do_mpfr_ckconv (m, type, inexact);
13968           mpfr_clear (m);
13969           if (result_lg)
13970             {
13971               tree result_sg;
13972
13973               /* Dereference the arg_sg pointer argument.  */
13974               arg_sg = build_fold_indirect_ref (arg_sg);
13975               /* Assign the signgam value into *arg_sg. */
13976               result_sg = fold_build2 (MODIFY_EXPR,
13977                                        TREE_TYPE (arg_sg), arg_sg,
13978                                        build_int_cst (TREE_TYPE (arg_sg), sg));
13979               TREE_SIDE_EFFECTS (result_sg) = 1;
13980               /* Combine the signgam assignment with the lgamma result.  */
13981               result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
13982                                                 result_sg, result_lg));
13983             }
13984         }
13985     }
13986
13987   return result;
13988 }
13989
13990 /* If argument ARG is a COMPLEX_CST, call the one-argument mpc
13991    function FUNC on it and return the resulting value as a tree with
13992    type TYPE.  The mpfr precision is set to the precision of TYPE.  We
13993    assume that function FUNC returns zero if the result could be
13994    calculated exactly within the requested precision.  */
13995
13996 static tree
13997 do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t))
13998 {
13999   tree result = NULL_TREE;
14000
14001   STRIP_NOPS (arg);
14002
14003   /* To proceed, MPFR must exactly represent the target floating point
14004      format, which only happens when the target base equals two.  */
14005   if (TREE_CODE (arg) == COMPLEX_CST && !TREE_OVERFLOW (arg)
14006       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE
14007       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg))))->b == 2)
14008     {
14009       const REAL_VALUE_TYPE *const re = TREE_REAL_CST_PTR (TREE_REALPART (arg));
14010       const REAL_VALUE_TYPE *const im = TREE_REAL_CST_PTR (TREE_IMAGPART (arg));
14011
14012       if (real_isfinite (re) && real_isfinite (im))
14013         {
14014           const struct real_format *const fmt =
14015             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
14016           const int prec = fmt->p;
14017           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
14018           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
14019           int inexact;
14020           mpc_t m;
14021
14022           mpc_init2 (m, prec);
14023           mpfr_from_real (mpc_realref(m), re, rnd);
14024           mpfr_from_real (mpc_imagref(m), im, rnd);
14025           mpfr_clear_flags ();
14026           inexact = func (m, m, crnd);
14027           result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
14028           mpc_clear (m);
14029         }
14030     }
14031
14032   return result;
14033 }
14034
14035 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
14036    mpc function FUNC on it and return the resulting value as a tree
14037    with type TYPE.  The mpfr precision is set to the precision of
14038    TYPE.  We assume that function FUNC returns zero if the result
14039    could be calculated exactly within the requested precision.  If
14040    DO_NONFINITE is true, then fold expressions containing Inf or NaN
14041    in the arguments and/or results.  */
14042
14043 tree
14044 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
14045              int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
14046 {
14047   tree result = NULL_TREE;
14048
14049   STRIP_NOPS (arg0);
14050   STRIP_NOPS (arg1);
14051
14052   /* To proceed, MPFR must exactly represent the target floating point
14053      format, which only happens when the target base equals two.  */
14054   if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
14055       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
14056       && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
14057       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
14058       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
14059     {
14060       const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
14061       const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
14062       const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
14063       const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
14064
14065       if (do_nonfinite
14066           || (real_isfinite (re0) && real_isfinite (im0)
14067               && real_isfinite (re1) && real_isfinite (im1)))
14068         {
14069           const struct real_format *const fmt =
14070             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
14071           const int prec = fmt->p;
14072           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
14073           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
14074           int inexact;
14075           mpc_t m0, m1;
14076
14077           mpc_init2 (m0, prec);
14078           mpc_init2 (m1, prec);
14079           mpfr_from_real (mpc_realref(m0), re0, rnd);
14080           mpfr_from_real (mpc_imagref(m0), im0, rnd);
14081           mpfr_from_real (mpc_realref(m1), re1, rnd);
14082           mpfr_from_real (mpc_imagref(m1), im1, rnd);
14083           mpfr_clear_flags ();
14084           inexact = func (m0, m0, m1, crnd);
14085           result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
14086           mpc_clear (m0);
14087           mpc_clear (m1);
14088         }
14089     }
14090
14091   return result;
14092 }
14093
14094 /* Fold a call STMT to __{,v}sprintf_chk.  Return NULL_TREE if
14095    a normal call should be emitted rather than expanding the function
14096    inline.  FCODE is either BUILT_IN_SPRINTF_CHK or BUILT_IN_VSPRINTF_CHK.  */
14097
14098 static tree
14099 gimple_fold_builtin_sprintf_chk (gimple stmt, enum built_in_function fcode)
14100 {
14101   int nargs = gimple_call_num_args (stmt);
14102
14103   return fold_builtin_sprintf_chk_1 (gimple_location (stmt), nargs,
14104                                      (nargs > 0
14105                                       ? gimple_call_arg_ptr (stmt, 0)
14106                                       : &error_mark_node), fcode);
14107 }
14108
14109 /* Fold a call STMT to {,v}snprintf.  Return NULL_TREE if
14110    a normal call should be emitted rather than expanding the function
14111    inline.  FCODE is either BUILT_IN_SNPRINTF_CHK or
14112    BUILT_IN_VSNPRINTF_CHK.  If MAXLEN is not NULL, it is maximum length
14113    passed as second argument.  */
14114
14115 tree
14116 gimple_fold_builtin_snprintf_chk (gimple stmt, tree maxlen,
14117                                   enum built_in_function fcode)
14118 {
14119   int nargs = gimple_call_num_args (stmt);
14120
14121   return fold_builtin_snprintf_chk_1 (gimple_location (stmt), nargs,
14122                                       (nargs > 0
14123                                        ? gimple_call_arg_ptr (stmt, 0)
14124                                        : &error_mark_node), maxlen, fcode);
14125 }
14126
14127 /* Builtins with folding operations that operate on "..." arguments
14128    need special handling; we need to store the arguments in a convenient
14129    data structure before attempting any folding.  Fortunately there are
14130    only a few builtins that fall into this category.  FNDECL is the
14131    function, EXP is the CALL_EXPR for the call, and IGNORE is true if the
14132    result of the function call is ignored.  */
14133
14134 static tree
14135 gimple_fold_builtin_varargs (tree fndecl, gimple stmt,
14136                              bool ignore ATTRIBUTE_UNUSED)
14137 {
14138   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
14139   tree ret = NULL_TREE;
14140
14141   switch (fcode)
14142     {
14143     case BUILT_IN_SPRINTF_CHK:
14144     case BUILT_IN_VSPRINTF_CHK:
14145       ret = gimple_fold_builtin_sprintf_chk (stmt, fcode);
14146       break;
14147
14148     case BUILT_IN_SNPRINTF_CHK:
14149     case BUILT_IN_VSNPRINTF_CHK:
14150       ret = gimple_fold_builtin_snprintf_chk (stmt, NULL_TREE, fcode);
14151
14152     default:
14153       break;
14154     }
14155   if (ret)
14156     {
14157       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
14158       TREE_NO_WARNING (ret) = 1;
14159       return ret;
14160     }
14161   return NULL_TREE;
14162 }
14163
14164 /* A wrapper function for builtin folding that prevents warnings for
14165    "statement without effect" and the like, caused by removing the
14166    call node earlier than the warning is generated.  */
14167
14168 tree
14169 fold_call_stmt (gimple stmt, bool ignore)
14170 {
14171   tree ret = NULL_TREE;
14172   tree fndecl = gimple_call_fndecl (stmt);
14173   location_t loc = gimple_location (stmt);
14174   if (fndecl
14175       && TREE_CODE (fndecl) == FUNCTION_DECL
14176       && DECL_BUILT_IN (fndecl)
14177       && !gimple_call_va_arg_pack_p (stmt))
14178     {
14179       int nargs = gimple_call_num_args (stmt);
14180       tree *args = (nargs > 0
14181                     ? gimple_call_arg_ptr (stmt, 0)
14182                     : &error_mark_node);
14183
14184       if (avoid_folding_inline_builtin (fndecl))
14185         return NULL_TREE;
14186       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
14187         {
14188           return targetm.fold_builtin (fndecl, nargs, args, ignore);
14189         }
14190       else
14191         {
14192           if (nargs <= MAX_ARGS_TO_FOLD_BUILTIN)
14193             ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
14194           if (!ret)
14195             ret = gimple_fold_builtin_varargs (fndecl, stmt, ignore);
14196           if (ret)
14197             {
14198               /* Propagate location information from original call to
14199                  expansion of builtin.  Otherwise things like
14200                  maybe_emit_chk_warning, that operate on the expansion
14201                  of a builtin, will use the wrong location information.  */
14202               if (gimple_has_location (stmt))
14203                 {
14204                   tree realret = ret;
14205                   if (TREE_CODE (ret) == NOP_EXPR)
14206                     realret = TREE_OPERAND (ret, 0);
14207                   if (CAN_HAVE_LOCATION_P (realret)
14208                       && !EXPR_HAS_LOCATION (realret))
14209                     SET_EXPR_LOCATION (realret, loc);
14210                   return realret;
14211                 }
14212               return ret;
14213             }
14214         }
14215     }
14216   return NULL_TREE;
14217 }
14218
14219 /* Look up the function in builtin_decl that corresponds to DECL
14220    and set ASMSPEC as its user assembler name.  DECL must be a
14221    function decl that declares a builtin.  */
14222
14223 void
14224 set_builtin_user_assembler_name (tree decl, const char *asmspec)
14225 {
14226   tree builtin;
14227   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
14228               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
14229               && asmspec != 0);
14230
14231   builtin = builtin_decl_explicit (DECL_FUNCTION_CODE (decl));
14232   set_user_assembler_name (builtin, asmspec);
14233   switch (DECL_FUNCTION_CODE (decl))
14234     {
14235     case BUILT_IN_MEMCPY:
14236       init_block_move_fn (asmspec);
14237       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
14238       break;
14239     case BUILT_IN_MEMSET:
14240       init_block_clear_fn (asmspec);
14241       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
14242       break;
14243     case BUILT_IN_MEMMOVE:
14244       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
14245       break;
14246     case BUILT_IN_MEMCMP:
14247       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
14248       break;
14249     case BUILT_IN_ABORT:
14250       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
14251       break;
14252     case BUILT_IN_FFS:
14253       if (INT_TYPE_SIZE < BITS_PER_WORD)
14254         {
14255           set_user_assembler_libfunc ("ffs", asmspec);
14256           set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
14257                                                        MODE_INT, 0), "ffs");
14258         }
14259       break;
14260     default:
14261       break;
14262     }
14263 }
14264
14265 /* Return true if DECL is a builtin that expands to a constant or similarly
14266    simple code.  */
14267 bool
14268 is_simple_builtin (tree decl)
14269 {
14270   if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
14271     switch (DECL_FUNCTION_CODE (decl))
14272       {
14273         /* Builtins that expand to constants.  */
14274       case BUILT_IN_CONSTANT_P:
14275       case BUILT_IN_EXPECT:
14276       case BUILT_IN_OBJECT_SIZE:
14277       case BUILT_IN_UNREACHABLE:
14278         /* Simple register moves or loads from stack.  */
14279       case BUILT_IN_ASSUME_ALIGNED:
14280       case BUILT_IN_RETURN_ADDRESS:
14281       case BUILT_IN_EXTRACT_RETURN_ADDR:
14282       case BUILT_IN_FROB_RETURN_ADDR:
14283       case BUILT_IN_RETURN:
14284       case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
14285       case BUILT_IN_FRAME_ADDRESS:
14286       case BUILT_IN_VA_END:
14287       case BUILT_IN_STACK_SAVE:
14288       case BUILT_IN_STACK_RESTORE:
14289         /* Exception state returns or moves registers around.  */
14290       case BUILT_IN_EH_FILTER:
14291       case BUILT_IN_EH_POINTER:
14292       case BUILT_IN_EH_COPY_VALUES:
14293         return true;
14294
14295       default:
14296         return false;
14297       }
14298
14299   return false;
14300 }
14301
14302 /* Return true if DECL is a builtin that is not expensive, i.e., they are
14303    most probably expanded inline into reasonably simple code.  This is a
14304    superset of is_simple_builtin.  */
14305 bool
14306 is_inexpensive_builtin (tree decl)
14307 {
14308   if (!decl)
14309     return false;
14310   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
14311     return true;
14312   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
14313     switch (DECL_FUNCTION_CODE (decl))
14314       {
14315       case BUILT_IN_ABS:
14316       case BUILT_IN_ALLOCA:
14317       case BUILT_IN_ALLOCA_WITH_ALIGN:
14318       case BUILT_IN_BSWAP16:
14319       case BUILT_IN_BSWAP32:
14320       case BUILT_IN_BSWAP64:
14321       case BUILT_IN_CLZ:
14322       case BUILT_IN_CLZIMAX:
14323       case BUILT_IN_CLZL:
14324       case BUILT_IN_CLZLL:
14325       case BUILT_IN_CTZ:
14326       case BUILT_IN_CTZIMAX:
14327       case BUILT_IN_CTZL:
14328       case BUILT_IN_CTZLL:
14329       case BUILT_IN_FFS:
14330       case BUILT_IN_FFSIMAX:
14331       case BUILT_IN_FFSL:
14332       case BUILT_IN_FFSLL:
14333       case BUILT_IN_IMAXABS:
14334       case BUILT_IN_FINITE:
14335       case BUILT_IN_FINITEF:
14336       case BUILT_IN_FINITEL:
14337       case BUILT_IN_FINITED32:
14338       case BUILT_IN_FINITED64:
14339       case BUILT_IN_FINITED128:
14340       case BUILT_IN_FPCLASSIFY:
14341       case BUILT_IN_ISFINITE:
14342       case BUILT_IN_ISINF_SIGN:
14343       case BUILT_IN_ISINF:
14344       case BUILT_IN_ISINFF:
14345       case BUILT_IN_ISINFL:
14346       case BUILT_IN_ISINFD32:
14347       case BUILT_IN_ISINFD64:
14348       case BUILT_IN_ISINFD128:
14349       case BUILT_IN_ISNAN:
14350       case BUILT_IN_ISNANF:
14351       case BUILT_IN_ISNANL:
14352       case BUILT_IN_ISNAND32:
14353       case BUILT_IN_ISNAND64:
14354       case BUILT_IN_ISNAND128:
14355       case BUILT_IN_ISNORMAL:
14356       case BUILT_IN_ISGREATER:
14357       case BUILT_IN_ISGREATEREQUAL:
14358       case BUILT_IN_ISLESS:
14359       case BUILT_IN_ISLESSEQUAL:
14360       case BUILT_IN_ISLESSGREATER:
14361       case BUILT_IN_ISUNORDERED:
14362       case BUILT_IN_VA_ARG_PACK:
14363       case BUILT_IN_VA_ARG_PACK_LEN:
14364       case BUILT_IN_VA_COPY:
14365       case BUILT_IN_TRAP:
14366       case BUILT_IN_SAVEREGS:
14367       case BUILT_IN_POPCOUNTL:
14368       case BUILT_IN_POPCOUNTLL:
14369       case BUILT_IN_POPCOUNTIMAX:
14370       case BUILT_IN_POPCOUNT:
14371       case BUILT_IN_PARITYL:
14372       case BUILT_IN_PARITYLL:
14373       case BUILT_IN_PARITYIMAX:
14374       case BUILT_IN_PARITY:
14375       case BUILT_IN_LABS:
14376       case BUILT_IN_LLABS:
14377       case BUILT_IN_PREFETCH:
14378         return true;
14379
14380       default:
14381         return is_simple_builtin (decl);
14382       }
14383
14384   return false;
14385 }