gcc/builtins.c

   1 /* Expand builtin functions.
   2    Copyright (C) 1988-2016 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 /* Legacy warning!  Please add no further builtin simplifications here
  21    (apart from pure constant folding) - builtin simplifications should go
  22    to match.pd or gimple-fold.c instead.  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "backend.h"
  28 #include "target.h"
  29 #include "rtl.h"
  30 #include "tree.h"
  31 #include "gimple.h"
  32 #include "predict.h"
  33 #include "tm_p.h"
  34 #include "stringpool.h"
  35 #include "tree-ssanames.h"
  36 #include "expmed.h"
  37 #include "optabs.h"
  38 #include "emit-rtl.h"
  39 #include "recog.h"
  40 #include "diagnostic-core.h"
  41 #include "alias.h"
  42 #include "fold-const.h"
  43 #include "fold-const-call.h"
  44 #include "stor-layout.h"
  45 #include "calls.h"
  46 #include "varasm.h"
  47 #include "tree-object-size.h"
  48 #include "realmpfr.h"
  49 #include "cfgrtl.h"
  50 #include "except.h"
  51 #include "dojump.h"
  52 #include "explow.h"
  53 #include "stmt.h"
  54 #include "expr.h"
  55 #include "libfuncs.h"
  56 #include "output.h"
  57 #include "typeclass.h"
  58 #include "langhooks.h"
  59 #include "value-prof.h"
  60 #include "builtins.h"
  61 #include "asan.h"
  62 #include "cilk.h"
  63 #include "tree-chkp.h"
  64 #include "rtl-chkp.h"
  65 #include "internal-fn.h"
  66 #include "case-cfn-macros.h"
  67
  68
  69 struct target_builtins default_target_builtins;
  70 #if SWITCHABLE_TARGET
  71 struct target_builtins *this_target_builtins = &default_target_builtins;
  72 #endif
  73
  74 /* Define the names of the builtin function types and codes.  */
  75 const char *const built_in_class_names[BUILT_IN_LAST]
  76   = {"NOT_BUILT_IN", "BUILT_IN_FRONTEND", "BUILT_IN_MD", "BUILT_IN_NORMAL"};
  77
  78 #define DEF_BUILTIN(X, N, C, T, LT, B, F, NA, AT, IM, COND) #X,
  79 const char * built_in_names[(int) END_BUILTINS] =
  80 {
  81 #include "builtins.def"
  82 };
  83
  84 /* Setup an array of builtin_info_type, make sure each element decl is
  85    initialized to NULL_TREE.  */
  86 builtin_info_type builtin_info[(int)END_BUILTINS];
  87
  88 /* Non-zero if __builtin_constant_p should be folded right away.  */
  89 bool force_folding_builtin_constant_p;
  90
  91 static rtx c_readstr (const char *, machine_mode);
  92 static int target_char_cast (tree, char *);
  93 static rtx get_memory_rtx (tree, tree);
  94 static int apply_args_size (void);
  95 static int apply_result_size (void);
  96 static rtx result_vector (int, rtx);
  97 static void expand_builtin_prefetch (tree);
  98 static rtx expand_builtin_apply_args (void);
  99 static rtx expand_builtin_apply_args_1 (void);
 100 static rtx expand_builtin_apply (rtx, rtx, rtx);
 101 static void expand_builtin_return (rtx);
 102 static enum type_class type_to_class (tree);
 103 static rtx expand_builtin_classify_type (tree);
 104 static rtx expand_builtin_mathfn_3 (tree, rtx, rtx);
 105 static rtx expand_builtin_mathfn_ternary (tree, rtx, rtx);
 106 static rtx expand_builtin_interclass_mathfn (tree, rtx);
 107 static rtx expand_builtin_sincos (tree);
 108 static rtx expand_builtin_cexpi (tree, rtx);
 109 static rtx expand_builtin_int_roundingfn (tree, rtx);
 110 static rtx expand_builtin_int_roundingfn_2 (tree, rtx);
 111 static rtx expand_builtin_next_arg (void);
 112 static rtx expand_builtin_va_start (tree);
 113 static rtx expand_builtin_va_end (tree);
 114 static rtx expand_builtin_va_copy (tree);
 115 static rtx expand_builtin_strcmp (tree, rtx);
 116 static rtx expand_builtin_strncmp (tree, rtx, machine_mode);
 117 static rtx builtin_memcpy_read_str (void *, HOST_WIDE_INT, machine_mode);
 118 static rtx expand_builtin_memcpy (tree, rtx);
 119 static rtx expand_builtin_memcpy_with_bounds (tree, rtx);
 120 static rtx expand_builtin_memcpy_args (tree, tree, tree, rtx, tree);
 121 static rtx expand_builtin_mempcpy (tree, rtx, machine_mode);
 122 static rtx expand_builtin_mempcpy_with_bounds (tree, rtx, machine_mode);
 123 static rtx expand_builtin_mempcpy_args (tree, tree, tree, rtx,
 124                                         machine_mode, int, tree);
 125 static rtx expand_builtin_strcpy (tree, rtx);
 126 static rtx expand_builtin_strcpy_args (tree, tree, rtx);
 127 static rtx expand_builtin_stpcpy (tree, rtx, machine_mode);
 128 static rtx expand_builtin_strncpy (tree, rtx);
 129 static rtx builtin_memset_gen_str (void *, HOST_WIDE_INT, machine_mode);
 130 static rtx expand_builtin_memset (tree, rtx, machine_mode);
 131 static rtx expand_builtin_memset_with_bounds (tree, rtx, machine_mode);
 132 static rtx expand_builtin_memset_args (tree, tree, tree, rtx, machine_mode, tree);
 133 static rtx expand_builtin_bzero (tree);
 134 static rtx expand_builtin_strlen (tree, rtx, machine_mode);
 135 static rtx expand_builtin_alloca (tree, bool);
 136 static rtx expand_builtin_unop (machine_mode, tree, rtx, rtx, optab);
 137 static rtx expand_builtin_frame_address (tree, tree);
 138 static tree stabilize_va_list_loc (location_t, tree, int);
 139 static rtx expand_builtin_expect (tree, rtx);
 140 static tree fold_builtin_constant_p (tree);
 141 static tree fold_builtin_classify_type (tree);
 142 static tree fold_builtin_strlen (location_t, tree, tree);
 143 static tree fold_builtin_inf (location_t, tree, int);
 144 static tree rewrite_call_expr (location_t, tree, int, tree, int, ...);
 145 static bool validate_arg (const_tree, enum tree_code code);
 146 static rtx expand_builtin_fabs (tree, rtx, rtx);
 147 static rtx expand_builtin_signbit (tree, rtx);
 148 static tree fold_builtin_strchr (location_t, tree, tree, tree);
 149 static tree fold_builtin_memchr (location_t, tree, tree, tree, tree);
 150 static tree fold_builtin_memcmp (location_t, tree, tree, tree);
 151 static tree fold_builtin_strcmp (location_t, tree, tree);
 152 static tree fold_builtin_strncmp (location_t, tree, tree, tree);
 153 static tree fold_builtin_isascii (location_t, tree);
 154 static tree fold_builtin_toascii (location_t, tree);
 155 static tree fold_builtin_isdigit (location_t, tree);
 156 static tree fold_builtin_fabs (location_t, tree, tree);
 157 static tree fold_builtin_abs (location_t, tree, tree);
 158 static tree fold_builtin_unordered_cmp (location_t, tree, tree, tree, enum tree_code,
 159                                         enum tree_code);
 160 static tree fold_builtin_0 (location_t, tree);
 161 static tree fold_builtin_1 (location_t, tree, tree);
 162 static tree fold_builtin_2 (location_t, tree, tree, tree);
 163 static tree fold_builtin_3 (location_t, tree, tree, tree, tree);
 164 static tree fold_builtin_varargs (location_t, tree, tree*, int);
 165
 166 static tree fold_builtin_strpbrk (location_t, tree, tree, tree);
 167 static tree fold_builtin_strstr (location_t, tree, tree, tree);
 168 static tree fold_builtin_strrchr (location_t, tree, tree, tree);
 169 static tree fold_builtin_strspn (location_t, tree, tree);
 170 static tree fold_builtin_strcspn (location_t, tree, tree);
 171
 172 static rtx expand_builtin_object_size (tree);
 173 static rtx expand_builtin_memory_chk (tree, rtx, machine_mode,
 174                                       enum built_in_function);
 175 static void maybe_emit_chk_warning (tree, enum built_in_function);
 176 static void maybe_emit_sprintf_chk_warning (tree, enum built_in_function);
 177 static void maybe_emit_free_warning (tree);
 178 static tree fold_builtin_object_size (tree, tree);
 179
 180 unsigned HOST_WIDE_INT target_newline;
 181 unsigned HOST_WIDE_INT target_percent;
 182 static unsigned HOST_WIDE_INT target_c;
 183 static unsigned HOST_WIDE_INT target_s;
 184 char target_percent_c[3];
 185 char target_percent_s[3];
 186 char target_percent_s_newline[4];
 187 static tree do_mpfr_remquo (tree, tree, tree);
 188 static tree do_mpfr_lgamma_r (tree, tree, tree);
 189 static void expand_builtin_sync_synchronize (void);
 190
 191 /* Return true if NAME starts with __builtin_ or __sync_.  */
 192
 193 static bool
 194 is_builtin_name (const char *name)
 195 {
 196   if (strncmp (name, "__builtin_", 10) == 0)
 197     return true;
 198   if (strncmp (name, "__sync_", 7) == 0)
 199     return true;
 200   if (strncmp (name, "__atomic_", 9) == 0)
 201     return true;
 202   if (flag_cilkplus
 203       && (!strcmp (name, "__cilkrts_detach")
 204           || !strcmp (name, "__cilkrts_pop_frame")))
 205     return true;
 206   return false;
 207 }
 208
 209
 210 /* Return true if DECL is a function symbol representing a built-in.  */
 211
 212 bool
 213 is_builtin_fn (tree decl)
 214 {
 215   return TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl);
 216 }
 217
 218 /* Return true if NODE should be considered for inline expansion regardless
 219    of the optimization level.  This means whenever a function is invoked with
 220    its "internal" name, which normally contains the prefix "__builtin".  */
 221
 222 bool
 223 called_as_built_in (tree node)
 224 {
 225   /* Note that we must use DECL_NAME, not DECL_ASSEMBLER_NAME_SET_P since
 226      we want the name used to call the function, not the name it
 227      will have. */
 228   const char *name = IDENTIFIER_POINTER (DECL_NAME (node));
 229   return is_builtin_name (name);
 230 }
 231
 232 /* Compute values M and N such that M divides (address of EXP - N) and such
 233    that N < M.  If these numbers can be determined, store M in alignp and N in
 234    *BITPOSP and return true.  Otherwise return false and store BITS_PER_UNIT to
 235    *alignp and any bit-offset to *bitposp.
 236
 237    Note that the address (and thus the alignment) computed here is based
 238    on the address to which a symbol resolves, whereas DECL_ALIGN is based
 239    on the address at which an object is actually located.  These two
 240    addresses are not always the same.  For example, on ARM targets,
 241    the address &foo of a Thumb function foo() has the lowest bit set,
 242    whereas foo() itself starts on an even address.
 243
 244    If ADDR_P is true we are taking the address of the memory reference EXP
 245    and thus cannot rely on the access taking place.  */
 246
 247 static bool
 248 get_object_alignment_2 (tree exp, unsigned int *alignp,
 249                         unsigned HOST_WIDE_INT *bitposp, bool addr_p)
 250 {
 251   HOST_WIDE_INT bitsize, bitpos;
 252   tree offset;
 253   machine_mode mode;
 254   int unsignedp, reversep, volatilep;
 255   unsigned int align = BITS_PER_UNIT;
 256   bool known_alignment = false;
 257
 258   /* Get the innermost object and the constant (bitpos) and possibly
 259      variable (offset) offset of the access.  */
 260   exp = get_inner_reference (exp, &bitsize, &bitpos, &offset, &mode,
 261                              &unsignedp, &reversep, &volatilep, true);
 262
 263   /* Extract alignment information from the innermost object and
 264      possibly adjust bitpos and offset.  */
 265   if (TREE_CODE (exp) == FUNCTION_DECL)
 266     {
 267       /* Function addresses can encode extra information besides their
 268          alignment.  However, if TARGET_PTRMEMFUNC_VBIT_LOCATION
 269          allows the low bit to be used as a virtual bit, we know
 270          that the address itself must be at least 2-byte aligned.  */
 271       if (TARGET_PTRMEMFUNC_VBIT_LOCATION == ptrmemfunc_vbit_in_pfn)
 272         align = 2 * BITS_PER_UNIT;
 273     }
 274   else if (TREE_CODE (exp) == LABEL_DECL)
 275     ;
 276   else if (TREE_CODE (exp) == CONST_DECL)
 277     {
 278       /* The alignment of a CONST_DECL is determined by its initializer.  */
 279       exp = DECL_INITIAL (exp);
 280       align = TYPE_ALIGN (TREE_TYPE (exp));
 281       if (CONSTANT_CLASS_P (exp))
 282         align = (unsigned) CONSTANT_ALIGNMENT (exp, align);
 283
 284       known_alignment = true;
 285     }
 286   else if (DECL_P (exp))
 287     {
 288       align = DECL_ALIGN (exp);
 289       known_alignment = true;
 290     }
 291   else if (TREE_CODE (exp) == VIEW_CONVERT_EXPR)
 292     {
 293       align = TYPE_ALIGN (TREE_TYPE (exp));
 294     }
 295   else if (TREE_CODE (exp) == INDIRECT_REF
 296            || TREE_CODE (exp) == MEM_REF
 297            || TREE_CODE (exp) == TARGET_MEM_REF)
 298     {
 299       tree addr = TREE_OPERAND (exp, 0);
 300       unsigned ptr_align;
 301       unsigned HOST_WIDE_INT ptr_bitpos;
 302       unsigned HOST_WIDE_INT ptr_bitmask = ~0;
 303
 304       /* If the address is explicitely aligned, handle that.  */
 305       if (TREE_CODE (addr) == BIT_AND_EXPR
 306           && TREE_CODE (TREE_OPERAND (addr, 1)) == INTEGER_CST)
 307         {
 308           ptr_bitmask = TREE_INT_CST_LOW (TREE_OPERAND (addr, 1));
 309           ptr_bitmask *= BITS_PER_UNIT;
 310           align = ptr_bitmask & -ptr_bitmask;
 311           addr = TREE_OPERAND (addr, 0);
 312         }
 313
 314       known_alignment
 315         = get_pointer_alignment_1 (addr, &ptr_align, &ptr_bitpos);
 316       align = MAX (ptr_align, align);
 317
 318       /* Re-apply explicit alignment to the bitpos.  */
 319       ptr_bitpos &= ptr_bitmask;
 320
 321       /* The alignment of the pointer operand in a TARGET_MEM_REF
 322          has to take the variable offset parts into account.  */
 323       if (TREE_CODE (exp) == TARGET_MEM_REF)
 324         {
 325           if (TMR_INDEX (exp))
 326             {
 327               unsigned HOST_WIDE_INT step = 1;
 328               if (TMR_STEP (exp))
 329                 step = TREE_INT_CST_LOW (TMR_STEP (exp));
 330               align = MIN (align, (step & -step) * BITS_PER_UNIT);
 331             }
 332           if (TMR_INDEX2 (exp))
 333             align = BITS_PER_UNIT;
 334           known_alignment = false;
 335         }
 336
 337       /* When EXP is an actual memory reference then we can use
 338          TYPE_ALIGN of a pointer indirection to derive alignment.
 339          Do so only if get_pointer_alignment_1 did not reveal absolute
 340          alignment knowledge and if using that alignment would
 341          improve the situation.  */
 342       if (!addr_p && !known_alignment
 343           && TYPE_ALIGN (TREE_TYPE (exp)) > align)
 344         align = TYPE_ALIGN (TREE_TYPE (exp));
 345       else
 346         {
 347           /* Else adjust bitpos accordingly.  */
 348           bitpos += ptr_bitpos;
 349           if (TREE_CODE (exp) == MEM_REF
 350               || TREE_CODE (exp) == TARGET_MEM_REF)
 351             bitpos += mem_ref_offset (exp).to_short_addr () * BITS_PER_UNIT;
 352         }
 353     }
 354   else if (TREE_CODE (exp) == STRING_CST)
 355     {
 356       /* STRING_CST are the only constant objects we allow to be not
 357          wrapped inside a CONST_DECL.  */
 358       align = TYPE_ALIGN (TREE_TYPE (exp));
 359       if (CONSTANT_CLASS_P (exp))
 360         align = (unsigned) CONSTANT_ALIGNMENT (exp, align);
 361
 362       known_alignment = true;
 363     }
 364
 365   /* If there is a non-constant offset part extract the maximum
 366      alignment that can prevail.  */
 367   if (offset)
 368     {
 369       unsigned int trailing_zeros = tree_ctz (offset);
 370       if (trailing_zeros < HOST_BITS_PER_INT)
 371         {
 372           unsigned int inner = (1U << trailing_zeros) * BITS_PER_UNIT;
 373           if (inner)
 374             align = MIN (align, inner);
 375         }
 376     }
 377
 378   *alignp = align;
 379   *bitposp = bitpos & (*alignp - 1);
 380   return known_alignment;
 381 }
 382
 383 /* For a memory reference expression EXP compute values M and N such that M
 384    divides (&EXP - N) and such that N < M.  If these numbers can be determined,
 385    store M in alignp and N in *BITPOSP and return true.  Otherwise return false
 386    and store BITS_PER_UNIT to *alignp and any bit-offset to *bitposp.  */
 387
 388 bool
 389 get_object_alignment_1 (tree exp, unsigned int *alignp,
 390                         unsigned HOST_WIDE_INT *bitposp)
 391 {
 392   return get_object_alignment_2 (exp, alignp, bitposp, false);
 393 }
 394
 395 /* Return the alignment in bits of EXP, an object.  */
 396
 397 unsigned int
 398 get_object_alignment (tree exp)
 399 {
 400   unsigned HOST_WIDE_INT bitpos = 0;
 401   unsigned int align;
 402
 403   get_object_alignment_1 (exp, &align, &bitpos);
 404
 405   /* align and bitpos now specify known low bits of the pointer.
 406      ptr & (align - 1) == bitpos.  */
 407
 408   if (bitpos != 0)
 409     align = (bitpos & -bitpos);
 410   return align;
 411 }
 412
 413 /* For a pointer valued expression EXP compute values M and N such that M
 414    divides (EXP - N) and such that N < M.  If these numbers can be determined,
 415    store M in alignp and N in *BITPOSP and return true.  Return false if
 416    the results are just a conservative approximation.
 417
 418    If EXP is not a pointer, false is returned too.  */
 419
 420 bool
 421 get_pointer_alignment_1 (tree exp, unsigned int *alignp,
 422                          unsigned HOST_WIDE_INT *bitposp)
 423 {
 424   STRIP_NOPS (exp);
 425
 426   if (TREE_CODE (exp) == ADDR_EXPR)
 427     return get_object_alignment_2 (TREE_OPERAND (exp, 0),
 428                                    alignp, bitposp, true);
 429   else if (TREE_CODE (exp) == POINTER_PLUS_EXPR)
 430     {
 431       unsigned int align;
 432       unsigned HOST_WIDE_INT bitpos;
 433       bool res = get_pointer_alignment_1 (TREE_OPERAND (exp, 0),
 434                                           &align, &bitpos);
 435       if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
 436         bitpos += TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)) * BITS_PER_UNIT;
 437       else
 438         {
 439           unsigned int trailing_zeros = tree_ctz (TREE_OPERAND (exp, 1));
 440           if (trailing_zeros < HOST_BITS_PER_INT)
 441             {
 442               unsigned int inner = (1U << trailing_zeros) * BITS_PER_UNIT;
 443               if (inner)
 444                 align = MIN (align, inner);
 445             }
 446         }
 447       *alignp = align;
 448       *bitposp = bitpos & (align - 1);
 449       return res;
 450     }
 451   else if (TREE_CODE (exp) == SSA_NAME
 452            && POINTER_TYPE_P (TREE_TYPE (exp)))
 453     {
 454       unsigned int ptr_align, ptr_misalign;
 455       struct ptr_info_def *pi = SSA_NAME_PTR_INFO (exp);
 456
 457       if (pi && get_ptr_info_alignment (pi, &ptr_align, &ptr_misalign))
 458         {
 459           *bitposp = ptr_misalign * BITS_PER_UNIT;
 460           *alignp = ptr_align * BITS_PER_UNIT;
 461           /* Make sure to return a sensible alignment when the multiplication
 462              by BITS_PER_UNIT overflowed.  */
 463           if (*alignp == 0)
 464             *alignp = 1u << (HOST_BITS_PER_INT - 1);
 465           /* We cannot really tell whether this result is an approximation.  */
 466           return true;
 467         }
 468       else
 469         {
 470           *bitposp = 0;
 471           *alignp = BITS_PER_UNIT;
 472           return false;
 473         }
 474     }
 475   else if (TREE_CODE (exp) == INTEGER_CST)
 476     {
 477       *alignp = BIGGEST_ALIGNMENT;
 478       *bitposp = ((TREE_INT_CST_LOW (exp) * BITS_PER_UNIT)
 479                   & (BIGGEST_ALIGNMENT - 1));
 480       return true;
 481     }
 482
 483   *bitposp = 0;
 484   *alignp = BITS_PER_UNIT;
 485   return false;
 486 }
 487
 488 /* Return the alignment in bits of EXP, a pointer valued expression.
 489    The alignment returned is, by default, the alignment of the thing that
 490    EXP points to.  If it is not a POINTER_TYPE, 0 is returned.
 491
 492    Otherwise, look at the expression to see if we can do better, i.e., if the
 493    expression is actually pointing at an object whose alignment is tighter.  */
 494
 495 unsigned int
 496 get_pointer_alignment (tree exp)
 497 {
 498   unsigned HOST_WIDE_INT bitpos = 0;
 499   unsigned int align;
 500
 501   get_pointer_alignment_1 (exp, &align, &bitpos);
 502
 503   /* align and bitpos now specify known low bits of the pointer.
 504      ptr & (align - 1) == bitpos.  */
 505
 506   if (bitpos != 0)
 507     align = (bitpos & -bitpos);
 508
 509   return align;
 510 }
 511
 512 /* Compute the length of a C string.  TREE_STRING_LENGTH is not the right
 513    way, because it could contain a zero byte in the middle.
 514    TREE_STRING_LENGTH is the size of the character array, not the string.
 515
 516    ONLY_VALUE should be nonzero if the result is not going to be emitted
 517    into the instruction stream and zero if it is going to be expanded.
 518    E.g. with i++ ? "foo" : "bar", if ONLY_VALUE is nonzero, constant 3
 519    is returned, otherwise NULL, since
 520    len = c_strlen (src, 1); if (len) expand_expr (len, ...); would not
 521    evaluate the side-effects.
 522
 523    If ONLY_VALUE is two then we do not emit warnings about out-of-bound
 524    accesses.  Note that this implies the result is not going to be emitted
 525    into the instruction stream.
 526
 527    The value returned is of type `ssizetype'.
 528
 529    Unfortunately, string_constant can't access the values of const char
 530    arrays with initializers, so neither can we do so here.  */
 531
 532 tree
 533 c_strlen (tree src, int only_value)
 534 {
 535   tree offset_node;
 536   HOST_WIDE_INT offset;
 537   int max;
 538   const char *ptr;
 539   location_t loc;
 540
 541   STRIP_NOPS (src);
 542   if (TREE_CODE (src) == COND_EXPR
 543       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 544     {
 545       tree len1, len2;
 546
 547       len1 = c_strlen (TREE_OPERAND (src, 1), only_value);
 548       len2 = c_strlen (TREE_OPERAND (src, 2), only_value);
 549       if (tree_int_cst_equal (len1, len2))
 550         return len1;
 551     }
 552
 553   if (TREE_CODE (src) == COMPOUND_EXPR
 554       && (only_value || !TREE_SIDE_EFFECTS (TREE_OPERAND (src, 0))))
 555     return c_strlen (TREE_OPERAND (src, 1), only_value);
 556
 557   loc = EXPR_LOC_OR_LOC (src, input_location);
 558
 559   src = string_constant (src, &offset_node);
 560   if (src == 0)
 561     return NULL_TREE;
 562
 563   max = TREE_STRING_LENGTH (src) - 1;
 564   ptr = TREE_STRING_POINTER (src);
 565
 566   if (offset_node && TREE_CODE (offset_node) != INTEGER_CST)
 567     {
 568       /* If the string has an internal zero byte (e.g., "foo\0bar"), we can't
 569          compute the offset to the following null if we don't know where to
 570          start searching for it.  */
 571       int i;
 572
 573       for (i = 0; i < max; i++)
 574         if (ptr[i] == 0)
 575           return NULL_TREE;
 576
 577       /* We don't know the starting offset, but we do know that the string
 578          has no internal zero bytes.  We can assume that the offset falls
 579          within the bounds of the string; otherwise, the programmer deserves
 580          what he gets.  Subtract the offset from the length of the string,
 581          and return that.  This would perhaps not be valid if we were dealing
 582          with named arrays in addition to literal string constants.  */
 583
 584       return size_diffop_loc (loc, size_int (max), offset_node);
 585     }
 586
 587   /* We have a known offset into the string.  Start searching there for
 588      a null character if we can represent it as a single HOST_WIDE_INT.  */
 589   if (offset_node == 0)
 590     offset = 0;
 591   else if (! tree_fits_shwi_p (offset_node))
 592     offset = -1;
 593   else
 594     offset = tree_to_shwi (offset_node);
 595
 596   /* If the offset is known to be out of bounds, warn, and call strlen at
 597      runtime.  */
 598   if (offset < 0 || offset > max)
 599     {
 600      /* Suppress multiple warnings for propagated constant strings.  */
 601       if (only_value != 2
 602           && !TREE_NO_WARNING (src))
 603         {
 604           warning_at (loc, 0, "offset outside bounds of constant string");
 605           TREE_NO_WARNING (src) = 1;
 606         }
 607       return NULL_TREE;
 608     }
 609
 610   /* Use strlen to search for the first zero byte.  Since any strings
 611      constructed with build_string will have nulls appended, we win even
 612      if we get handed something like (char[4])"abcd".
 613
 614      Since OFFSET is our starting index into the string, no further
 615      calculation is needed.  */
 616   return ssize_int (strlen (ptr + offset));
 617 }
 618
 619 /* Return a constant integer corresponding to target reading
 620    GET_MODE_BITSIZE (MODE) bits from string constant STR.  */
 621
 622 static rtx
 623 c_readstr (const char *str, machine_mode mode)
 624 {
 625   HOST_WIDE_INT ch;
 626   unsigned int i, j;
 627   HOST_WIDE_INT tmp[MAX_BITSIZE_MODE_ANY_INT / HOST_BITS_PER_WIDE_INT];
 628
 629   gcc_assert (GET_MODE_CLASS (mode) == MODE_INT);
 630   unsigned int len = (GET_MODE_PRECISION (mode) + HOST_BITS_PER_WIDE_INT - 1)
 631     / HOST_BITS_PER_WIDE_INT;
 632
 633   gcc_assert (len <= MAX_BITSIZE_MODE_ANY_INT / HOST_BITS_PER_WIDE_INT);
 634   for (i = 0; i < len; i++)
 635     tmp[i] = 0;
 636
 637   ch = 1;
 638   for (i = 0; i < GET_MODE_SIZE (mode); i++)
 639     {
 640       j = i;
 641       if (WORDS_BIG_ENDIAN)
 642         j = GET_MODE_SIZE (mode) - i - 1;
 643       if (BYTES_BIG_ENDIAN != WORDS_BIG_ENDIAN
 644           && GET_MODE_SIZE (mode) >= UNITS_PER_WORD)
 645         j = j + UNITS_PER_WORD - 2 * (j % UNITS_PER_WORD) - 1;
 646       j *= BITS_PER_UNIT;
 647
 648       if (ch)
 649         ch = (unsigned char) str[i];
 650       tmp[j / HOST_BITS_PER_WIDE_INT] |= ch << (j % HOST_BITS_PER_WIDE_INT);
 651     }
 652
 653   wide_int c = wide_int::from_array (tmp, len, GET_MODE_PRECISION (mode));
 654   return immed_wide_int_const (c, mode);
 655 }
 656
 657 /* Cast a target constant CST to target CHAR and if that value fits into
 658    host char type, return zero and put that value into variable pointed to by
 659    P.  */
 660
 661 static int
 662 target_char_cast (tree cst, char *p)
 663 {
 664   unsigned HOST_WIDE_INT val, hostval;
 665
 666   if (TREE_CODE (cst) != INTEGER_CST
 667       || CHAR_TYPE_SIZE > HOST_BITS_PER_WIDE_INT)
 668     return 1;
 669
 670   /* Do not care if it fits or not right here.  */
 671   val = TREE_INT_CST_LOW (cst);
 672
 673   if (CHAR_TYPE_SIZE < HOST_BITS_PER_WIDE_INT)
 674     val &= (((unsigned HOST_WIDE_INT) 1) << CHAR_TYPE_SIZE) - 1;
 675
 676   hostval = val;
 677   if (HOST_BITS_PER_CHAR < HOST_BITS_PER_WIDE_INT)
 678     hostval &= (((unsigned HOST_WIDE_INT) 1) << HOST_BITS_PER_CHAR) - 1;
 679
 680   if (val != hostval)
 681     return 1;
 682
 683   *p = hostval;
 684   return 0;
 685 }
 686
 687 /* Similar to save_expr, but assumes that arbitrary code is not executed
 688    in between the multiple evaluations.  In particular, we assume that a
 689    non-addressable local variable will not be modified.  */
 690
 691 static tree
 692 builtin_save_expr (tree exp)
 693 {
 694   if (TREE_CODE (exp) == SSA_NAME
 695       || (TREE_ADDRESSABLE (exp) == 0
 696           && (TREE_CODE (exp) == PARM_DECL
 697               || (TREE_CODE (exp) == VAR_DECL && !TREE_STATIC (exp)))))
 698     return exp;
 699
 700   return save_expr (exp);
 701 }
 702
 703 /* Given TEM, a pointer to a stack frame, follow the dynamic chain COUNT
 704    times to get the address of either a higher stack frame, or a return
 705    address located within it (depending on FNDECL_CODE).  */
 706
 707 static rtx
 708 expand_builtin_return_addr (enum built_in_function fndecl_code, int count)
 709 {
 710   int i;
 711   rtx tem = INITIAL_FRAME_ADDRESS_RTX;
 712   if (tem == NULL_RTX)
 713     {
 714       /* For a zero count with __builtin_return_address, we don't care what
 715          frame address we return, because target-specific definitions will
 716          override us.  Therefore frame pointer elimination is OK, and using
 717          the soft frame pointer is OK.
 718
 719          For a nonzero count, or a zero count with __builtin_frame_address,
 720          we require a stable offset from the current frame pointer to the
 721          previous one, so we must use the hard frame pointer, and
 722          we must disable frame pointer elimination.  */
 723       if (count == 0 && fndecl_code == BUILT_IN_RETURN_ADDRESS)
 724         tem = frame_pointer_rtx;
 725       else
 726         {
 727           tem = hard_frame_pointer_rtx;
 728
 729           /* Tell reload not to eliminate the frame pointer.  */
 730           crtl->accesses_prior_frames = 1;
 731         }
 732     }
 733
 734   if (count > 0)
 735     SETUP_FRAME_ADDRESSES ();
 736
 737   /* On the SPARC, the return address is not in the frame, it is in a
 738      register.  There is no way to access it off of the current frame
 739      pointer, but it can be accessed off the previous frame pointer by
 740      reading the value from the register window save area.  */
 741   if (RETURN_ADDR_IN_PREVIOUS_FRAME && fndecl_code == BUILT_IN_RETURN_ADDRESS)
 742     count--;
 743
 744   /* Scan back COUNT frames to the specified frame.  */
 745   for (i = 0; i < count; i++)
 746     {
 747       /* Assume the dynamic chain pointer is in the word that the
 748          frame address points to, unless otherwise specified.  */
 749       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 750       tem = memory_address (Pmode, tem);
 751       tem = gen_frame_mem (Pmode, tem);
 752       tem = copy_to_reg (tem);
 753     }
 754
 755   /* For __builtin_frame_address, return what we've got.  But, on
 756      the SPARC for example, we may have to add a bias.  */
 757   if (fndecl_code == BUILT_IN_FRAME_ADDRESS)
 758     return FRAME_ADDR_RTX (tem);
 759
 760   /* For __builtin_return_address, get the return address from that frame.  */
 761 #ifdef RETURN_ADDR_RTX
 762   tem = RETURN_ADDR_RTX (count, tem);
 763 #else
 764   tem = memory_address (Pmode,
 765                         plus_constant (Pmode, tem, GET_MODE_SIZE (Pmode)));
 766   tem = gen_frame_mem (Pmode, tem);
 767 #endif
 768   return tem;
 769 }
 770
 771 /* Alias set used for setjmp buffer.  */
 772 static alias_set_type setjmp_alias_set = -1;
 773
 774 /* Construct the leading half of a __builtin_setjmp call.  Control will
 775    return to RECEIVER_LABEL.  This is also called directly by the SJLJ
 776    exception handling code.  */
 777
 778 void
 779 expand_builtin_setjmp_setup (rtx buf_addr, rtx receiver_label)
 780 {
 781   machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 782   rtx stack_save;
 783   rtx mem;
 784
 785   if (setjmp_alias_set == -1)
 786     setjmp_alias_set = new_alias_set ();
 787
 788   buf_addr = convert_memory_address (Pmode, buf_addr);
 789
 790   buf_addr = force_reg (Pmode, force_operand (buf_addr, NULL_RTX));
 791
 792   /* We store the frame pointer and the address of receiver_label in
 793      the buffer and use the rest of it for the stack save area, which
 794      is machine-dependent.  */
 795
 796   mem = gen_rtx_MEM (Pmode, buf_addr);
 797   set_mem_alias_set (mem, setjmp_alias_set);
 798   emit_move_insn (mem, targetm.builtin_setjmp_frame_value ());
 799
 800   mem = gen_rtx_MEM (Pmode, plus_constant (Pmode, buf_addr,
 801                                            GET_MODE_SIZE (Pmode))),
 802   set_mem_alias_set (mem, setjmp_alias_set);
 803
 804   emit_move_insn (validize_mem (mem),
 805                   force_reg (Pmode, gen_rtx_LABEL_REF (Pmode, receiver_label)));
 806
 807   stack_save = gen_rtx_MEM (sa_mode,
 808                             plus_constant (Pmode, buf_addr,
 809                                            2 * GET_MODE_SIZE (Pmode)));
 810   set_mem_alias_set (stack_save, setjmp_alias_set);
 811   emit_stack_save (SAVE_NONLOCAL, &stack_save);
 812
 813   /* If there is further processing to do, do it.  */
 814   if (targetm.have_builtin_setjmp_setup ())
 815     emit_insn (targetm.gen_builtin_setjmp_setup (buf_addr));
 816
 817   /* We have a nonlocal label.   */
 818   cfun->has_nonlocal_label = 1;
 819 }
 820
 821 /* Construct the trailing part of a __builtin_setjmp call.  This is
 822    also called directly by the SJLJ exception handling code.
 823    If RECEIVER_LABEL is NULL, instead contruct a nonlocal goto handler.  */
 824
 825 void
 826 expand_builtin_setjmp_receiver (rtx receiver_label)
 827 {
 828   rtx chain;
 829
 830   /* Mark the FP as used when we get here, so we have to make sure it's
 831      marked as used by this function.  */
 832   emit_use (hard_frame_pointer_rtx);
 833
 834   /* Mark the static chain as clobbered here so life information
 835      doesn't get messed up for it.  */
 836   chain = targetm.calls.static_chain (current_function_decl, true);
 837   if (chain && REG_P (chain))
 838     emit_clobber (chain);
 839
 840   /* Now put in the code to restore the frame pointer, and argument
 841      pointer, if needed.  */
 842   if (! targetm.have_nonlocal_goto ())
 843     {
 844       /* First adjust our frame pointer to its actual value.  It was
 845          previously set to the start of the virtual area corresponding to
 846          the stacked variables when we branched here and now needs to be
 847          adjusted to the actual hardware fp value.
 848
 849          Assignments to virtual registers are converted by
 850          instantiate_virtual_regs into the corresponding assignment
 851          to the underlying register (fp in this case) that makes
 852          the original assignment true.
 853          So the following insn will actually be decrementing fp by
 854          STARTING_FRAME_OFFSET.  */
 855       emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
 856
 857       /* Restoring the frame pointer also modifies the hard frame pointer.
 858          Mark it used (so that the previous assignment remains live once
 859          the frame pointer is eliminated) and clobbered (to represent the
 860          implicit update from the assignment).  */
 861       emit_use (hard_frame_pointer_rtx);
 862       emit_clobber (hard_frame_pointer_rtx);
 863     }
 864
 865   if (!HARD_FRAME_POINTER_IS_ARG_POINTER && fixed_regs[ARG_POINTER_REGNUM])
 866     {
 867 #ifdef ELIMINABLE_REGS
 868       /* If the argument pointer can be eliminated in favor of the
 869          frame pointer, we don't need to restore it.  We assume here
 870          that if such an elimination is present, it can always be used.
 871          This is the case on all known machines; if we don't make this
 872          assumption, we do unnecessary saving on many machines.  */
 873       size_t i;
 874       static const struct elims {const int from, to;} elim_regs[] = ELIMINABLE_REGS;
 875
 876       for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
 877         if (elim_regs[i].from == ARG_POINTER_REGNUM
 878             && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
 879           break;
 880
 881       if (i == ARRAY_SIZE (elim_regs))
 882 #endif
 883         {
 884           /* Now restore our arg pointer from the address at which it
 885              was saved in our stack frame.  */
 886           emit_move_insn (crtl->args.internal_arg_pointer,
 887                           copy_to_reg (get_arg_pointer_save_area ()));
 888         }
 889     }
 890
 891   if (receiver_label != NULL && targetm.have_builtin_setjmp_receiver ())
 892     emit_insn (targetm.gen_builtin_setjmp_receiver (receiver_label));
 893   else if (targetm.have_nonlocal_goto_receiver ())
 894     emit_insn (targetm.gen_nonlocal_goto_receiver ());
 895   else
 896     { /* Nothing */ }
 897
 898   /* We must not allow the code we just generated to be reordered by
 899      scheduling.  Specifically, the update of the frame pointer must
 900      happen immediately, not later.  */
 901   emit_insn (gen_blockage ());
 902 }
 903
 904 /* __builtin_longjmp is passed a pointer to an array of five words (not
 905    all will be used on all machines).  It operates similarly to the C
 906    library function of the same name, but is more efficient.  Much of
 907    the code below is copied from the handling of non-local gotos.  */
 908
 909 static void
 910 expand_builtin_longjmp (rtx buf_addr, rtx value)
 911 {
 912   rtx fp, lab, stack;
 913   rtx_insn *insn, *last;
 914   machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
 915
 916   /* DRAP is needed for stack realign if longjmp is expanded to current
 917      function  */
 918   if (SUPPORTS_STACK_ALIGNMENT)
 919     crtl->need_drap = true;
 920
 921   if (setjmp_alias_set == -1)
 922     setjmp_alias_set = new_alias_set ();
 923
 924   buf_addr = convert_memory_address (Pmode, buf_addr);
 925
 926   buf_addr = force_reg (Pmode, buf_addr);
 927
 928   /* We require that the user must pass a second argument of 1, because
 929      that is what builtin_setjmp will return.  */
 930   gcc_assert (value == const1_rtx);
 931
 932   last = get_last_insn ();
 933   if (targetm.have_builtin_longjmp ())
 934     emit_insn (targetm.gen_builtin_longjmp (buf_addr));
 935   else
 936     {
 937       fp = gen_rtx_MEM (Pmode, buf_addr);
 938       lab = gen_rtx_MEM (Pmode, plus_constant (Pmode, buf_addr,
 939                                                GET_MODE_SIZE (Pmode)));
 940
 941       stack = gen_rtx_MEM (sa_mode, plus_constant (Pmode, buf_addr,
 942                                                    2 * GET_MODE_SIZE (Pmode)));
 943       set_mem_alias_set (fp, setjmp_alias_set);
 944       set_mem_alias_set (lab, setjmp_alias_set);
 945       set_mem_alias_set (stack, setjmp_alias_set);
 946
 947       /* Pick up FP, label, and SP from the block and jump.  This code is
 948          from expand_goto in stmt.c; see there for detailed comments.  */
 949       if (targetm.have_nonlocal_goto ())
 950         /* We have to pass a value to the nonlocal_goto pattern that will
 951            get copied into the static_chain pointer, but it does not matter
 952            what that value is, because builtin_setjmp does not use it.  */
 953         emit_insn (targetm.gen_nonlocal_goto (value, lab, stack, fp));
 954       else
 955         {
 956           lab = copy_to_reg (lab);
 957
 958           emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
 959           emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
 960
 961           emit_move_insn (hard_frame_pointer_rtx, fp);
 962           emit_stack_restore (SAVE_NONLOCAL, stack);
 963
 964           emit_use (hard_frame_pointer_rtx);
 965           emit_use (stack_pointer_rtx);
 966           emit_indirect_jump (lab);
 967         }
 968     }
 969
 970   /* Search backwards and mark the jump insn as a non-local goto.
 971      Note that this precludes the use of __builtin_longjmp to a
 972      __builtin_setjmp target in the same function.  However, we've
 973      already cautioned the user that these functions are for
 974      internal exception handling use only.  */
 975   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
 976     {
 977       gcc_assert (insn != last);
 978
 979       if (JUMP_P (insn))
 980         {
 981           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
 982           break;
 983         }
 984       else if (CALL_P (insn))
 985         break;
 986     }
 987 }
 988
 989 static inline bool
 990 more_const_call_expr_args_p (const const_call_expr_arg_iterator *iter)
 991 {
 992   return (iter->i < iter->n);
 993 }
 994
 995 /* This function validates the types of a function call argument list
 996    against a specified list of tree_codes.  If the last specifier is a 0,
 997    that represents an ellipses, otherwise the last specifier must be a
 998    VOID_TYPE.  */
 999
1000 static bool
1001 validate_arglist (const_tree callexpr, ...)
1002 {
1003   enum tree_code code;
1004   bool res = 0;
1005   va_list ap;
1006   const_call_expr_arg_iterator iter;
1007   const_tree arg;
1008
1009   va_start (ap, callexpr);
1010   init_const_call_expr_arg_iterator (callexpr, &iter);
1011
1012   do
1013     {
1014       code = (enum tree_code) va_arg (ap, int);
1015       switch (code)
1016         {
1017         case 0:
1018           /* This signifies an ellipses, any further arguments are all ok.  */
1019           res = true;
1020           goto end;
1021         case VOID_TYPE:
1022           /* This signifies an endlink, if no arguments remain, return
1023              true, otherwise return false.  */
1024           res = !more_const_call_expr_args_p (&iter);
1025           goto end;
1026         default:
1027           /* If no parameters remain or the parameter's code does not
1028              match the specified code, return false.  Otherwise continue
1029              checking any remaining arguments.  */
1030           arg = next_const_call_expr_arg (&iter);
1031           if (!validate_arg (arg, code))
1032             goto end;
1033           break;
1034         }
1035     }
1036   while (1);
1037
1038   /* We need gotos here since we can only have one VA_CLOSE in a
1039      function.  */
1040  end: ;
1041   va_end (ap);
1042
1043   return res;
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;
1054   rtx_insn *insn;
1055
1056   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
1057     return NULL_RTX;
1058
1059   t_label = CALL_EXPR_ARG (exp, 0);
1060   t_save_area = CALL_EXPR_ARG (exp, 1);
1061
1062   r_label = expand_normal (t_label);
1063   r_label = convert_memory_address (Pmode, r_label);
1064   r_save_area = expand_normal (t_save_area);
1065   r_save_area = convert_memory_address (Pmode, r_save_area);
1066   /* Copy the address of the save location to a register just in case it was
1067      based on the frame pointer.   */
1068   r_save_area = copy_to_reg (r_save_area);
1069   r_fp = gen_rtx_MEM (Pmode, r_save_area);
1070   r_sp = gen_rtx_MEM (STACK_SAVEAREA_MODE (SAVE_NONLOCAL),
1071                       plus_constant (Pmode, r_save_area,
1072                                      GET_MODE_SIZE (Pmode)));
1073
1074   crtl->has_nonlocal_goto = 1;
1075
1076   /* ??? We no longer need to pass the static chain value, afaik.  */
1077   if (targetm.have_nonlocal_goto ())
1078     emit_insn (targetm.gen_nonlocal_goto (const0_rtx, r_label, r_sp, r_fp));
1079   else
1080     {
1081       r_label = copy_to_reg (r_label);
1082
1083       emit_clobber (gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode)));
1084       emit_clobber (gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx));
1085
1086       /* Restore frame pointer for containing function.  */
1087       emit_move_insn (hard_frame_pointer_rtx, r_fp);
1088       emit_stack_restore (SAVE_NONLOCAL, r_sp);
1089
1090       /* USE of hard_frame_pointer_rtx added for consistency;
1091          not clear if really needed.  */
1092       emit_use (hard_frame_pointer_rtx);
1093       emit_use (stack_pointer_rtx);
1094
1095       /* If the architecture is using a GP register, we must
1096          conservatively assume that the target function makes use of it.
1097          The prologue of functions with nonlocal gotos must therefore
1098          initialize the GP register to the appropriate value, and we
1099          must then make sure that this value is live at the point
1100          of the jump.  (Note that this doesn't necessarily apply
1101          to targets with a nonlocal_goto pattern; they are free
1102          to implement it in their own way.  Note also that this is
1103          a no-op if the GP register is a global invariant.)  */
1104       if ((unsigned) PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
1105           && fixed_regs[PIC_OFFSET_TABLE_REGNUM])
1106         emit_use (pic_offset_table_rtx);
1107
1108       emit_indirect_jump (r_label);
1109     }
1110
1111   /* Search backwards to the jump insn and mark it as a
1112      non-local goto.  */
1113   for (insn = get_last_insn (); insn; insn = PREV_INSN (insn))
1114     {
1115       if (JUMP_P (insn))
1116         {
1117           add_reg_note (insn, REG_NON_LOCAL_GOTO, const0_rtx);
1118           break;
1119         }
1120       else if (CALL_P (insn))
1121         break;
1122     }
1123
1124   return const0_rtx;
1125 }
1126
1127 /* __builtin_update_setjmp_buf is passed a pointer to an array of five words
1128    (not all will be used on all machines) that was passed to __builtin_setjmp.
1129    It updates the stack pointer in that block to the current value.  This is
1130    also called directly by the SJLJ exception handling code.  */
1131
1132 void
1133 expand_builtin_update_setjmp_buf (rtx buf_addr)
1134 {
1135   machine_mode sa_mode = STACK_SAVEAREA_MODE (SAVE_NONLOCAL);
1136   rtx stack_save
1137     = gen_rtx_MEM (sa_mode,
1138                    memory_address
1139                    (sa_mode,
1140                     plus_constant (Pmode, buf_addr,
1141                                    2 * GET_MODE_SIZE (Pmode))));
1142
1143   emit_stack_save (SAVE_NONLOCAL, &stack_save);
1144 }
1145
1146 /* Expand a call to __builtin_prefetch.  For a target that does not support
1147    data prefetch, evaluate the memory address argument in case it has side
1148    effects.  */
1149
1150 static void
1151 expand_builtin_prefetch (tree exp)
1152 {
1153   tree arg0, arg1, arg2;
1154   int nargs;
1155   rtx op0, op1, op2;
1156
1157   if (!validate_arglist (exp, POINTER_TYPE, 0))
1158     return;
1159
1160   arg0 = CALL_EXPR_ARG (exp, 0);
1161
1162   /* Arguments 1 and 2 are optional; argument 1 (read/write) defaults to
1163      zero (read) and argument 2 (locality) defaults to 3 (high degree of
1164      locality).  */
1165   nargs = call_expr_nargs (exp);
1166   if (nargs > 1)
1167     arg1 = CALL_EXPR_ARG (exp, 1);
1168   else
1169     arg1 = integer_zero_node;
1170   if (nargs > 2)
1171     arg2 = CALL_EXPR_ARG (exp, 2);
1172   else
1173     arg2 = integer_three_node;
1174
1175   /* Argument 0 is an address.  */
1176   op0 = expand_expr (arg0, NULL_RTX, Pmode, EXPAND_NORMAL);
1177
1178   /* Argument 1 (read/write flag) must be a compile-time constant int.  */
1179   if (TREE_CODE (arg1) != INTEGER_CST)
1180     {
1181       error ("second argument to %<__builtin_prefetch%> must be a constant");
1182       arg1 = integer_zero_node;
1183     }
1184   op1 = expand_normal (arg1);
1185   /* Argument 1 must be either zero or one.  */
1186   if (INTVAL (op1) != 0 && INTVAL (op1) != 1)
1187     {
1188       warning (0, "invalid second argument to %<__builtin_prefetch%>;"
1189                " using zero");
1190       op1 = const0_rtx;
1191     }
1192
1193   /* Argument 2 (locality) must be a compile-time constant int.  */
1194   if (TREE_CODE (arg2) != INTEGER_CST)
1195     {
1196       error ("third argument to %<__builtin_prefetch%> must be a constant");
1197       arg2 = integer_zero_node;
1198     }
1199   op2 = expand_normal (arg2);
1200   /* Argument 2 must be 0, 1, 2, or 3.  */
1201   if (INTVAL (op2) < 0 || INTVAL (op2) > 3)
1202     {
1203       warning (0, "invalid third argument to %<__builtin_prefetch%>; using zero");
1204       op2 = const0_rtx;
1205     }
1206
1207   if (targetm.have_prefetch ())
1208     {
1209       struct expand_operand ops[3];
1210
1211       create_address_operand (&ops[0], op0);
1212       create_integer_operand (&ops[1], INTVAL (op1));
1213       create_integer_operand (&ops[2], INTVAL (op2));
1214       if (maybe_expand_insn (targetm.code_for_prefetch, 3, ops))
1215         return;
1216     }
1217
1218   /* Don't do anything with direct references to volatile memory, but
1219      generate code to handle other side effects.  */
1220   if (!MEM_P (op0) && side_effects_p (op0))
1221     emit_insn (op0);
1222 }
1223
1224 /* Get a MEM rtx for expression EXP which is the address of an operand
1225    to be used in a string instruction (cmpstrsi, movmemsi, ..).  LEN is
1226    the maximum length of the block of memory that might be accessed or
1227    NULL if unknown.  */
1228
1229 static rtx
1230 get_memory_rtx (tree exp, tree len)
1231 {
1232   tree orig_exp = exp;
1233   rtx addr, mem;
1234
1235   /* When EXP is not resolved SAVE_EXPR, MEM_ATTRS can be still derived
1236      from its expression, for expr->a.b only <variable>.a.b is recorded.  */
1237   if (TREE_CODE (exp) == SAVE_EXPR && !SAVE_EXPR_RESOLVED_P (exp))
1238     exp = TREE_OPERAND (exp, 0);
1239
1240   addr = expand_expr (orig_exp, NULL_RTX, ptr_mode, EXPAND_NORMAL);
1241   mem = gen_rtx_MEM (BLKmode, memory_address (BLKmode, addr));
1242
1243   /* Get an expression we can use to find the attributes to assign to MEM.
1244      First remove any nops.  */
1245   while (CONVERT_EXPR_P (exp)
1246          && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (exp, 0))))
1247     exp = TREE_OPERAND (exp, 0);
1248
1249   /* Build a MEM_REF representing the whole accessed area as a byte blob,
1250      (as builtin stringops may alias with anything).  */
1251   exp = fold_build2 (MEM_REF,
1252                      build_array_type (char_type_node,
1253                                        build_range_type (sizetype,
1254                                                          size_one_node, len)),
1255                      exp, build_int_cst (ptr_type_node, 0));
1256
1257   /* If the MEM_REF has no acceptable address, try to get the base object
1258      from the original address we got, and build an all-aliasing
1259      unknown-sized access to that one.  */
1260   if (is_gimple_mem_ref_addr (TREE_OPERAND (exp, 0)))
1261     set_mem_attributes (mem, exp, 0);
1262   else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
1263            && (exp = get_base_address (TREE_OPERAND (TREE_OPERAND (exp, 0),
1264                                                      0))))
1265     {
1266       exp = build_fold_addr_expr (exp);
1267       exp = fold_build2 (MEM_REF,
1268                          build_array_type (char_type_node,
1269                                            build_range_type (sizetype,
1270                                                              size_zero_node,
1271                                                              NULL)),
1272                          exp, build_int_cst (ptr_type_node, 0));
1273       set_mem_attributes (mem, exp, 0);
1274     }
1275   set_mem_alias_set (mem, 0);
1276   return mem;
1277 }
1278 \f
1279 /* Built-in functions to perform an untyped call and return.  */
1280
1281 #define apply_args_mode \
1282   (this_target_builtins->x_apply_args_mode)
1283 #define apply_result_mode \
1284   (this_target_builtins->x_apply_result_mode)
1285
1286 /* Return the size required for the block returned by __builtin_apply_args,
1287    and initialize apply_args_mode.  */
1288
1289 static int
1290 apply_args_size (void)
1291 {
1292   static int size = -1;
1293   int align;
1294   unsigned int regno;
1295   machine_mode mode;
1296
1297   /* The values computed by this function never change.  */
1298   if (size < 0)
1299     {
1300       /* The first value is the incoming arg-pointer.  */
1301       size = GET_MODE_SIZE (Pmode);
1302
1303       /* The second value is the structure value address unless this is
1304          passed as an "invisible" first argument.  */
1305       if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1306         size += GET_MODE_SIZE (Pmode);
1307
1308       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1309         if (FUNCTION_ARG_REGNO_P (regno))
1310           {
1311             mode = targetm.calls.get_raw_arg_mode (regno);
1312
1313             gcc_assert (mode != VOIDmode);
1314
1315             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1316             if (size % align != 0)
1317               size = CEIL (size, align) * align;
1318             size += GET_MODE_SIZE (mode);
1319             apply_args_mode[regno] = mode;
1320           }
1321         else
1322           {
1323             apply_args_mode[regno] = VOIDmode;
1324           }
1325     }
1326   return size;
1327 }
1328
1329 /* Return the size required for the block returned by __builtin_apply,
1330    and initialize apply_result_mode.  */
1331
1332 static int
1333 apply_result_size (void)
1334 {
1335   static int size = -1;
1336   int align, regno;
1337   machine_mode mode;
1338
1339   /* The values computed by this function never change.  */
1340   if (size < 0)
1341     {
1342       size = 0;
1343
1344       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1345         if (targetm.calls.function_value_regno_p (regno))
1346           {
1347             mode = targetm.calls.get_raw_result_mode (regno);
1348
1349             gcc_assert (mode != VOIDmode);
1350
1351             align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1352             if (size % align != 0)
1353               size = CEIL (size, align) * align;
1354             size += GET_MODE_SIZE (mode);
1355             apply_result_mode[regno] = mode;
1356           }
1357         else
1358           apply_result_mode[regno] = VOIDmode;
1359
1360       /* Allow targets that use untyped_call and untyped_return to override
1361          the size so that machine-specific information can be stored here.  */
1362 #ifdef APPLY_RESULT_SIZE
1363       size = APPLY_RESULT_SIZE;
1364 #endif
1365     }
1366   return size;
1367 }
1368
1369 /* Create a vector describing the result block RESULT.  If SAVEP is true,
1370    the result block is used to save the values; otherwise it is used to
1371    restore the values.  */
1372
1373 static rtx
1374 result_vector (int savep, rtx result)
1375 {
1376   int regno, size, align, nelts;
1377   machine_mode mode;
1378   rtx reg, mem;
1379   rtx *savevec = XALLOCAVEC (rtx, FIRST_PSEUDO_REGISTER);
1380
1381   size = nelts = 0;
1382   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1383     if ((mode = apply_result_mode[regno]) != VOIDmode)
1384       {
1385         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1386         if (size % align != 0)
1387           size = CEIL (size, align) * align;
1388         reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
1389         mem = adjust_address (result, mode, size);
1390         savevec[nelts++] = (savep
1391                             ? gen_rtx_SET (mem, reg)
1392                             : gen_rtx_SET (reg, mem));
1393         size += GET_MODE_SIZE (mode);
1394       }
1395   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
1396 }
1397
1398 /* Save the state required to perform an untyped call with the same
1399    arguments as were passed to the current function.  */
1400
1401 static rtx
1402 expand_builtin_apply_args_1 (void)
1403 {
1404   rtx registers, tem;
1405   int size, align, regno;
1406   machine_mode mode;
1407   rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1);
1408
1409   /* Create a block where the arg-pointer, structure value address,
1410      and argument registers can be saved.  */
1411   registers = assign_stack_local (BLKmode, apply_args_size (), -1);
1412
1413   /* Walk past the arg-pointer and structure value address.  */
1414   size = GET_MODE_SIZE (Pmode);
1415   if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0))
1416     size += GET_MODE_SIZE (Pmode);
1417
1418   /* Save each register used in calling a function to the block.  */
1419   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1420     if ((mode = apply_args_mode[regno]) != VOIDmode)
1421       {
1422         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1423         if (size % align != 0)
1424           size = CEIL (size, align) * align;
1425
1426         tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1427
1428         emit_move_insn (adjust_address (registers, mode, size), tem);
1429         size += GET_MODE_SIZE (mode);
1430       }
1431
1432   /* Save the arg pointer to the block.  */
1433   tem = copy_to_reg (crtl->args.internal_arg_pointer);
1434   /* We need the pointer as the caller actually passed them to us, not
1435      as we might have pretended they were passed.  Make sure it's a valid
1436      operand, as emit_move_insn isn't expected to handle a PLUS.  */
1437   if (STACK_GROWS_DOWNWARD)
1438     tem
1439       = force_operand (plus_constant (Pmode, tem,
1440                                       crtl->args.pretend_args_size),
1441                        NULL_RTX);
1442   emit_move_insn (adjust_address (registers, Pmode, 0), tem);
1443
1444   size = GET_MODE_SIZE (Pmode);
1445
1446   /* Save the structure value address unless this is passed as an
1447      "invisible" first argument.  */
1448   if (struct_incoming_value)
1449     {
1450       emit_move_insn (adjust_address (registers, Pmode, size),
1451                       copy_to_reg (struct_incoming_value));
1452       size += GET_MODE_SIZE (Pmode);
1453     }
1454
1455   /* Return the address of the block.  */
1456   return copy_addr_to_reg (XEXP (registers, 0));
1457 }
1458
1459 /* __builtin_apply_args returns block of memory allocated on
1460    the stack into which is stored the arg pointer, structure
1461    value address, static chain, and all the registers that might
1462    possibly be used in performing a function call.  The code is
1463    moved to the start of the function so the incoming values are
1464    saved.  */
1465
1466 static rtx
1467 expand_builtin_apply_args (void)
1468 {
1469   /* Don't do __builtin_apply_args more than once in a function.
1470      Save the result of the first call and reuse it.  */
1471   if (apply_args_value != 0)
1472     return apply_args_value;
1473   {
1474     /* When this function is called, it means that registers must be
1475        saved on entry to this function.  So we migrate the
1476        call to the first insn of this function.  */
1477     rtx temp;
1478
1479     start_sequence ();
1480     temp = expand_builtin_apply_args_1 ();
1481     rtx_insn *seq = get_insns ();
1482     end_sequence ();
1483
1484     apply_args_value = temp;
1485
1486     /* Put the insns after the NOTE that starts the function.
1487        If this is inside a start_sequence, make the outer-level insn
1488        chain current, so the code is placed at the start of the
1489        function.  If internal_arg_pointer is a non-virtual pseudo,
1490        it needs to be placed after the function that initializes
1491        that pseudo.  */
1492     push_topmost_sequence ();
1493     if (REG_P (crtl->args.internal_arg_pointer)
1494         && REGNO (crtl->args.internal_arg_pointer) > LAST_VIRTUAL_REGISTER)
1495       emit_insn_before (seq, parm_birth_insn);
1496     else
1497       emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
1498     pop_topmost_sequence ();
1499     return temp;
1500   }
1501 }
1502
1503 /* Perform an untyped call and save the state required to perform an
1504    untyped return of whatever value was returned by the given function.  */
1505
1506 static rtx
1507 expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
1508 {
1509   int size, align, regno;
1510   machine_mode mode;
1511   rtx incoming_args, result, reg, dest, src;
1512   rtx_call_insn *call_insn;
1513   rtx old_stack_level = 0;
1514   rtx call_fusage = 0;
1515   rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0);
1516
1517   arguments = convert_memory_address (Pmode, arguments);
1518
1519   /* Create a block where the return registers can be saved.  */
1520   result = assign_stack_local (BLKmode, apply_result_size (), -1);
1521
1522   /* Fetch the arg pointer from the ARGUMENTS block.  */
1523   incoming_args = gen_reg_rtx (Pmode);
1524   emit_move_insn (incoming_args, gen_rtx_MEM (Pmode, arguments));
1525   if (!STACK_GROWS_DOWNWARD)
1526     incoming_args = expand_simple_binop (Pmode, MINUS, incoming_args, argsize,
1527                                          incoming_args, 0, OPTAB_LIB_WIDEN);
1528
1529   /* Push a new argument block and copy the arguments.  Do not allow
1530      the (potential) memcpy call below to interfere with our stack
1531      manipulations.  */
1532   do_pending_stack_adjust ();
1533   NO_DEFER_POP;
1534
1535   /* Save the stack with nonlocal if available.  */
1536   if (targetm.have_save_stack_nonlocal ())
1537     emit_stack_save (SAVE_NONLOCAL, &old_stack_level);
1538   else
1539     emit_stack_save (SAVE_BLOCK, &old_stack_level);
1540
1541   /* Allocate a block of memory onto the stack and copy the memory
1542      arguments to the outgoing arguments address.  We can pass TRUE
1543      as the 4th argument because we just saved the stack pointer
1544      and will restore it right after the call.  */
1545   allocate_dynamic_stack_space (argsize, 0, BIGGEST_ALIGNMENT, true);
1546
1547   /* Set DRAP flag to true, even though allocate_dynamic_stack_space
1548      may have already set current_function_calls_alloca to true.
1549      current_function_calls_alloca won't be set if argsize is zero,
1550      so we have to guarantee need_drap is true here.  */
1551   if (SUPPORTS_STACK_ALIGNMENT)
1552     crtl->need_drap = true;
1553
1554   dest = virtual_outgoing_args_rtx;
1555   if (!STACK_GROWS_DOWNWARD)
1556     {
1557       if (CONST_INT_P (argsize))
1558         dest = plus_constant (Pmode, dest, -INTVAL (argsize));
1559       else
1560         dest = gen_rtx_PLUS (Pmode, dest, negate_rtx (Pmode, argsize));
1561     }
1562   dest = gen_rtx_MEM (BLKmode, dest);
1563   set_mem_align (dest, PARM_BOUNDARY);
1564   src = gen_rtx_MEM (BLKmode, incoming_args);
1565   set_mem_align (src, PARM_BOUNDARY);
1566   emit_block_move (dest, src, argsize, BLOCK_OP_NORMAL);
1567
1568   /* Refer to the argument block.  */
1569   apply_args_size ();
1570   arguments = gen_rtx_MEM (BLKmode, arguments);
1571   set_mem_align (arguments, PARM_BOUNDARY);
1572
1573   /* Walk past the arg-pointer and structure value address.  */
1574   size = GET_MODE_SIZE (Pmode);
1575   if (struct_value)
1576     size += GET_MODE_SIZE (Pmode);
1577
1578   /* Restore each of the registers previously saved.  Make USE insns
1579      for each of these registers for use in making the call.  */
1580   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1581     if ((mode = apply_args_mode[regno]) != VOIDmode)
1582       {
1583         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1584         if (size % align != 0)
1585           size = CEIL (size, align) * align;
1586         reg = gen_rtx_REG (mode, regno);
1587         emit_move_insn (reg, adjust_address (arguments, mode, size));
1588         use_reg (&call_fusage, reg);
1589         size += GET_MODE_SIZE (mode);
1590       }
1591
1592   /* Restore the structure value address unless this is passed as an
1593      "invisible" first argument.  */
1594   size = GET_MODE_SIZE (Pmode);
1595   if (struct_value)
1596     {
1597       rtx value = gen_reg_rtx (Pmode);
1598       emit_move_insn (value, adjust_address (arguments, Pmode, size));
1599       emit_move_insn (struct_value, value);
1600       if (REG_P (struct_value))
1601         use_reg (&call_fusage, struct_value);
1602       size += GET_MODE_SIZE (Pmode);
1603     }
1604
1605   /* All arguments and registers used for the call are set up by now!  */
1606   function = prepare_call_address (NULL, function, NULL, &call_fusage, 0, 0);
1607
1608   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
1609      and we don't want to load it into a register as an optimization,
1610      because prepare_call_address already did it if it should be done.  */
1611   if (GET_CODE (function) != SYMBOL_REF)
1612     function = memory_address (FUNCTION_MODE, function);
1613
1614   /* Generate the actual call instruction and save the return value.  */
1615   if (targetm.have_untyped_call ())
1616     {
1617       rtx mem = gen_rtx_MEM (FUNCTION_MODE, function);
1618       emit_call_insn (targetm.gen_untyped_call (mem, result,
1619                                                 result_vector (1, result)));
1620     }
1621   else if (targetm.have_call_value ())
1622     {
1623       rtx valreg = 0;
1624
1625       /* Locate the unique return register.  It is not possible to
1626          express a call that sets more than one return register using
1627          call_value; use untyped_call for that.  In fact, untyped_call
1628          only needs to save the return registers in the given block.  */
1629       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1630         if ((mode = apply_result_mode[regno]) != VOIDmode)
1631           {
1632             gcc_assert (!valreg); /* have_untyped_call required.  */
1633
1634             valreg = gen_rtx_REG (mode, regno);
1635           }
1636
1637       emit_insn (targetm.gen_call_value (valreg,
1638                                          gen_rtx_MEM (FUNCTION_MODE, function),
1639                                          const0_rtx, NULL_RTX, const0_rtx));
1640
1641       emit_move_insn (adjust_address (result, GET_MODE (valreg), 0), valreg);
1642     }
1643   else
1644     gcc_unreachable ();
1645
1646   /* Find the CALL insn we just emitted, and attach the register usage
1647      information.  */
1648   call_insn = last_call_insn ();
1649   add_function_usage_to (call_insn, call_fusage);
1650
1651   /* Restore the stack.  */
1652   if (targetm.have_save_stack_nonlocal ())
1653     emit_stack_restore (SAVE_NONLOCAL, old_stack_level);
1654   else
1655     emit_stack_restore (SAVE_BLOCK, old_stack_level);
1656   fixup_args_size_notes (call_insn, get_last_insn (), 0);
1657
1658   OK_DEFER_POP;
1659
1660   /* Return the address of the result block.  */
1661   result = copy_addr_to_reg (XEXP (result, 0));
1662   return convert_memory_address (ptr_mode, result);
1663 }
1664
1665 /* Perform an untyped return.  */
1666
1667 static void
1668 expand_builtin_return (rtx result)
1669 {
1670   int size, align, regno;
1671   machine_mode mode;
1672   rtx reg;
1673   rtx_insn *call_fusage = 0;
1674
1675   result = convert_memory_address (Pmode, result);
1676
1677   apply_result_size ();
1678   result = gen_rtx_MEM (BLKmode, result);
1679
1680   if (targetm.have_untyped_return ())
1681     {
1682       rtx vector = result_vector (0, result);
1683       emit_jump_insn (targetm.gen_untyped_return (result, vector));
1684       emit_barrier ();
1685       return;
1686     }
1687
1688   /* Restore the return value and note that each value is used.  */
1689   size = 0;
1690   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1691     if ((mode = apply_result_mode[regno]) != VOIDmode)
1692       {
1693         align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
1694         if (size % align != 0)
1695           size = CEIL (size, align) * align;
1696         reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
1697         emit_move_insn (reg, adjust_address (result, mode, size));
1698
1699         push_to_sequence (call_fusage);
1700         emit_use (reg);
1701         call_fusage = get_insns ();
1702         end_sequence ();
1703         size += GET_MODE_SIZE (mode);
1704       }
1705
1706   /* Put the USE insns before the return.  */
1707   emit_insn (call_fusage);
1708
1709   /* Return whatever values was restored by jumping directly to the end
1710      of the function.  */
1711   expand_naked_return ();
1712 }
1713
1714 /* Used by expand_builtin_classify_type and fold_builtin_classify_type.  */
1715
1716 static enum type_class
1717 type_to_class (tree type)
1718 {
1719   switch (TREE_CODE (type))
1720     {
1721     case VOID_TYPE:        return void_type_class;
1722     case INTEGER_TYPE:     return integer_type_class;
1723     case ENUMERAL_TYPE:    return enumeral_type_class;
1724     case BOOLEAN_TYPE:     return boolean_type_class;
1725     case POINTER_TYPE:     return pointer_type_class;
1726     case REFERENCE_TYPE:   return reference_type_class;
1727     case OFFSET_TYPE:      return offset_type_class;
1728     case REAL_TYPE:        return real_type_class;
1729     case COMPLEX_TYPE:     return complex_type_class;
1730     case FUNCTION_TYPE:    return function_type_class;
1731     case METHOD_TYPE:      return method_type_class;
1732     case RECORD_TYPE:      return record_type_class;
1733     case UNION_TYPE:
1734     case QUAL_UNION_TYPE:  return union_type_class;
1735     case ARRAY_TYPE:       return (TYPE_STRING_FLAG (type)
1736                                    ? string_type_class : array_type_class);
1737     case LANG_TYPE:        return lang_type_class;
1738     default:               return no_type_class;
1739     }
1740 }
1741
1742 /* Expand a call EXP to __builtin_classify_type.  */
1743
1744 static rtx
1745 expand_builtin_classify_type (tree exp)
1746 {
1747   if (call_expr_nargs (exp))
1748     return GEN_INT (type_to_class (TREE_TYPE (CALL_EXPR_ARG (exp, 0))));
1749   return GEN_INT (no_type_class);
1750 }
1751
1752 /* This helper macro, meant to be used in mathfn_built_in below,
1753    determines which among a set of three builtin math functions is
1754    appropriate for a given type mode.  The `F' and `L' cases are
1755    automatically generated from the `double' case.  */
1756 #define CASE_MATHFN(MATHFN) \
1757   CASE_CFN_##MATHFN: \
1758   fcode = BUILT_IN_##MATHFN; fcodef = BUILT_IN_##MATHFN##F ; \
1759   fcodel = BUILT_IN_##MATHFN##L ; break;
1760 /* Similar to above, but appends _R after any F/L suffix.  */
1761 #define CASE_MATHFN_REENT(MATHFN) \
1762   case CFN_BUILT_IN_##MATHFN##_R: \
1763   case CFN_BUILT_IN_##MATHFN##F_R: \
1764   case CFN_BUILT_IN_##MATHFN##L_R: \
1765   fcode = BUILT_IN_##MATHFN##_R; fcodef = BUILT_IN_##MATHFN##F_R ; \
1766   fcodel = BUILT_IN_##MATHFN##L_R ; break;
1767
1768 /* Return a function equivalent to FN but operating on floating-point
1769    values of type TYPE, or END_BUILTINS if no such function exists.
1770    This is purely an operation on function codes; it does not guarantee
1771    that the target actually has an implementation of the function.  */
1772
1773 static built_in_function
1774 mathfn_built_in_2 (tree type, combined_fn fn)
1775 {
1776   built_in_function fcode, fcodef, fcodel;
1777
1778   switch (fn)
1779     {
1780     CASE_MATHFN (ACOS)
1781     CASE_MATHFN (ACOSH)
1782     CASE_MATHFN (ASIN)
1783     CASE_MATHFN (ASINH)
1784     CASE_MATHFN (ATAN)
1785     CASE_MATHFN (ATAN2)
1786     CASE_MATHFN (ATANH)
1787     CASE_MATHFN (CBRT)
1788     CASE_MATHFN (CEIL)
1789     CASE_MATHFN (CEXPI)
1790     CASE_MATHFN (COPYSIGN)
1791     CASE_MATHFN (COS)
1792     CASE_MATHFN (COSH)
1793     CASE_MATHFN (DREM)
1794     CASE_MATHFN (ERF)
1795     CASE_MATHFN (ERFC)
1796     CASE_MATHFN (EXP)
1797     CASE_MATHFN (EXP10)
1798     CASE_MATHFN (EXP2)
1799     CASE_MATHFN (EXPM1)
1800     CASE_MATHFN (FABS)
1801     CASE_MATHFN (FDIM)
1802     CASE_MATHFN (FLOOR)
1803     CASE_MATHFN (FMA)
1804     CASE_MATHFN (FMAX)
1805     CASE_MATHFN (FMIN)
1806     CASE_MATHFN (FMOD)
1807     CASE_MATHFN (FREXP)
1808     CASE_MATHFN (GAMMA)
1809     CASE_MATHFN_REENT (GAMMA) /* GAMMA_R */
1810     CASE_MATHFN (HUGE_VAL)
1811     CASE_MATHFN (HYPOT)
1812     CASE_MATHFN (ILOGB)
1813     CASE_MATHFN (ICEIL)
1814     CASE_MATHFN (IFLOOR)
1815     CASE_MATHFN (INF)
1816     CASE_MATHFN (IRINT)
1817     CASE_MATHFN (IROUND)
1818     CASE_MATHFN (ISINF)
1819     CASE_MATHFN (J0)
1820     CASE_MATHFN (J1)
1821     CASE_MATHFN (JN)
1822     CASE_MATHFN (LCEIL)
1823     CASE_MATHFN (LDEXP)
1824     CASE_MATHFN (LFLOOR)
1825     CASE_MATHFN (LGAMMA)
1826     CASE_MATHFN_REENT (LGAMMA) /* LGAMMA_R */
1827     CASE_MATHFN (LLCEIL)
1828     CASE_MATHFN (LLFLOOR)
1829     CASE_MATHFN (LLRINT)
1830     CASE_MATHFN (LLROUND)
1831     CASE_MATHFN (LOG)
1832     CASE_MATHFN (LOG10)
1833     CASE_MATHFN (LOG1P)
1834     CASE_MATHFN (LOG2)
1835     CASE_MATHFN (LOGB)
1836     CASE_MATHFN (LRINT)
1837     CASE_MATHFN (LROUND)
1838     CASE_MATHFN (MODF)
1839     CASE_MATHFN (NAN)
1840     CASE_MATHFN (NANS)
1841     CASE_MATHFN (NEARBYINT)
1842     CASE_MATHFN (NEXTAFTER)
1843     CASE_MATHFN (NEXTTOWARD)
1844     CASE_MATHFN (POW)
1845     CASE_MATHFN (POWI)
1846     CASE_MATHFN (POW10)
1847     CASE_MATHFN (REMAINDER)
1848     CASE_MATHFN (REMQUO)
1849     CASE_MATHFN (RINT)
1850     CASE_MATHFN (ROUND)
1851     CASE_MATHFN (SCALB)
1852     CASE_MATHFN (SCALBLN)
1853     CASE_MATHFN (SCALBN)
1854     CASE_MATHFN (SIGNBIT)
1855     CASE_MATHFN (SIGNIFICAND)
1856     CASE_MATHFN (SIN)
1857     CASE_MATHFN (SINCOS)
1858     CASE_MATHFN (SINH)
1859     CASE_MATHFN (SQRT)
1860     CASE_MATHFN (TAN)
1861     CASE_MATHFN (TANH)
1862     CASE_MATHFN (TGAMMA)
1863     CASE_MATHFN (TRUNC)
1864     CASE_MATHFN (Y0)
1865     CASE_MATHFN (Y1)
1866     CASE_MATHFN (YN)
1867
1868     default:
1869       return END_BUILTINS;
1870     }
1871
1872   if (TYPE_MAIN_VARIANT (type) == double_type_node)
1873     return fcode;
1874   else if (TYPE_MAIN_VARIANT (type) == float_type_node)
1875     return fcodef;
1876   else if (TYPE_MAIN_VARIANT (type) == long_double_type_node)
1877     return fcodel;
1878   else
1879     return END_BUILTINS;
1880 }
1881
1882 /* Return mathematic function equivalent to FN but operating directly on TYPE,
1883    if available.  If IMPLICIT_P is true use the implicit builtin declaration,
1884    otherwise use the explicit declaration.  If we can't do the conversion,
1885    return null.  */
1886
1887 static tree
1888 mathfn_built_in_1 (tree type, combined_fn fn, bool implicit_p)
1889 {
1890   built_in_function fcode2 = mathfn_built_in_2 (type, fn);
1891   if (fcode2 == END_BUILTINS)
1892     return NULL_TREE;
1893
1894   if (implicit_p && !builtin_decl_implicit_p (fcode2))
1895     return NULL_TREE;
1896
1897   return builtin_decl_explicit (fcode2);
1898 }
1899
1900 /* Like mathfn_built_in_1, but always use the implicit array.  */
1901
1902 tree
1903 mathfn_built_in (tree type, combined_fn fn)
1904 {
1905   return mathfn_built_in_1 (type, fn, /*implicit=*/ 1);
1906 }
1907
1908 /* Like mathfn_built_in_1, but take a built_in_function and
1909    always use the implicit array.  */
1910
1911 tree
1912 mathfn_built_in (tree type, enum built_in_function fn)
1913 {
1914   return mathfn_built_in_1 (type, as_combined_fn (fn), /*implicit=*/ 1);
1915 }
1916
1917 /* If BUILT_IN_NORMAL function FNDECL has an associated internal function,
1918    return its code, otherwise return IFN_LAST.  Note that this function
1919    only tests whether the function is defined in internals.def, not whether
1920    it is actually available on the target.  */
1921
1922 internal_fn
1923 associated_internal_fn (tree fndecl)
1924 {
1925   gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL);
1926   tree return_type = TREE_TYPE (TREE_TYPE (fndecl));
1927   switch (DECL_FUNCTION_CODE (fndecl))
1928     {
1929 #define DEF_INTERNAL_FLT_FN(NAME, FLAGS, OPTAB, TYPE) \
1930     CASE_FLT_FN (BUILT_IN_##NAME): return IFN_##NAME;
1931 #define DEF_INTERNAL_INT_FN(NAME, FLAGS, OPTAB, TYPE) \
1932     CASE_INT_FN (BUILT_IN_##NAME): return IFN_##NAME;
1933 #include "internal-fn.def"
1934
1935     CASE_FLT_FN (BUILT_IN_POW10):
1936       return IFN_EXP10;
1937
1938     CASE_FLT_FN (BUILT_IN_DREM):
1939       return IFN_REMAINDER;
1940
1941     CASE_FLT_FN (BUILT_IN_SCALBN):
1942     CASE_FLT_FN (BUILT_IN_SCALBLN):
1943       if (REAL_MODE_FORMAT (TYPE_MODE (return_type))->b == 2)
1944         return IFN_LDEXP;
1945       return IFN_LAST;
1946
1947     default:
1948       return IFN_LAST;
1949     }
1950 }
1951
1952 /* If CALL is a call to a BUILT_IN_NORMAL function that could be replaced
1953    on the current target by a call to an internal function, return the
1954    code of that internal function, otherwise return IFN_LAST.  The caller
1955    is responsible for ensuring that any side-effects of the built-in
1956    call are dealt with correctly.  E.g. if CALL sets errno, the caller
1957    must decide that the errno result isn't needed or make it available
1958    in some other way.  */
1959
1960 internal_fn
1961 replacement_internal_fn (gcall *call)
1962 {
1963   if (gimple_call_builtin_p (call, BUILT_IN_NORMAL))
1964     {
1965       internal_fn ifn = associated_internal_fn (gimple_call_fndecl (call));
1966       if (ifn != IFN_LAST)
1967         {
1968           tree_pair types = direct_internal_fn_types (ifn, call);
1969           optimization_type opt_type = bb_optimization_type (gimple_bb (call));
1970           if (direct_internal_fn_supported_p (ifn, types, opt_type))
1971             return ifn;
1972         }
1973     }
1974   return IFN_LAST;
1975 }
1976
1977 /* Expand a call to the builtin trinary math functions (fma).
1978    Return NULL_RTX if a normal call should be emitted rather than expanding the
1979    function in-line.  EXP is the expression that is a call to the builtin
1980    function; if convenient, the result should be placed in TARGET.
1981    SUBTARGET may be used as the target for computing one of EXP's
1982    operands.  */
1983
1984 static rtx
1985 expand_builtin_mathfn_ternary (tree exp, rtx target, rtx subtarget)
1986 {
1987   optab builtin_optab;
1988   rtx op0, op1, op2, result;
1989   rtx_insn *insns;
1990   tree fndecl = get_callee_fndecl (exp);
1991   tree arg0, arg1, arg2;
1992   machine_mode mode;
1993
1994   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, REAL_TYPE, VOID_TYPE))
1995     return NULL_RTX;
1996
1997   arg0 = CALL_EXPR_ARG (exp, 0);
1998   arg1 = CALL_EXPR_ARG (exp, 1);
1999   arg2 = CALL_EXPR_ARG (exp, 2);
2000
2001   switch (DECL_FUNCTION_CODE (fndecl))
2002     {
2003     CASE_FLT_FN (BUILT_IN_FMA):
2004       builtin_optab = fma_optab; break;
2005     default:
2006       gcc_unreachable ();
2007     }
2008
2009   /* Make a suitable register to place result in.  */
2010   mode = TYPE_MODE (TREE_TYPE (exp));
2011
2012   /* Before working hard, check whether the instruction is available.  */
2013   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2014     return NULL_RTX;
2015
2016   result = gen_reg_rtx (mode);
2017
2018   /* Always stabilize the argument list.  */
2019   CALL_EXPR_ARG (exp, 0) = arg0 = builtin_save_expr (arg0);
2020   CALL_EXPR_ARG (exp, 1) = arg1 = builtin_save_expr (arg1);
2021   CALL_EXPR_ARG (exp, 2) = arg2 = builtin_save_expr (arg2);
2022
2023   op0 = expand_expr (arg0, subtarget, VOIDmode, EXPAND_NORMAL);
2024   op1 = expand_normal (arg1);
2025   op2 = expand_normal (arg2);
2026
2027   start_sequence ();
2028
2029   /* Compute into RESULT.
2030      Set RESULT to wherever the result comes back.  */
2031   result = expand_ternary_op (mode, builtin_optab, op0, op1, op2,
2032                               result, 0);
2033
2034   /* If we were unable to expand via the builtin, stop the sequence
2035      (without outputting the insns) and call to the library function
2036      with the stabilized argument list.  */
2037   if (result == 0)
2038     {
2039       end_sequence ();
2040       return expand_call (exp, target, target == const0_rtx);
2041     }
2042
2043   /* Output the entire sequence.  */
2044   insns = get_insns ();
2045   end_sequence ();
2046   emit_insn (insns);
2047
2048   return result;
2049 }
2050
2051 /* Expand a call to the builtin sin and cos math functions.
2052    Return NULL_RTX if a normal call should be emitted rather than expanding the
2053    function in-line.  EXP is the expression that is a call to the builtin
2054    function; if convenient, the result should be placed in TARGET.
2055    SUBTARGET may be used as the target for computing one of EXP's
2056    operands.  */
2057
2058 static rtx
2059 expand_builtin_mathfn_3 (tree exp, rtx target, rtx subtarget)
2060 {
2061   optab builtin_optab;
2062   rtx op0;
2063   rtx_insn *insns;
2064   tree fndecl = get_callee_fndecl (exp);
2065   machine_mode mode;
2066   tree arg;
2067
2068   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2069     return NULL_RTX;
2070
2071   arg = CALL_EXPR_ARG (exp, 0);
2072
2073   switch (DECL_FUNCTION_CODE (fndecl))
2074     {
2075     CASE_FLT_FN (BUILT_IN_SIN):
2076     CASE_FLT_FN (BUILT_IN_COS):
2077       builtin_optab = sincos_optab; break;
2078     default:
2079       gcc_unreachable ();
2080     }
2081
2082   /* Make a suitable register to place result in.  */
2083   mode = TYPE_MODE (TREE_TYPE (exp));
2084
2085   /* Check if sincos insn is available, otherwise fallback
2086      to sin or cos insn.  */
2087   if (optab_handler (builtin_optab, mode) == CODE_FOR_nothing)
2088     switch (DECL_FUNCTION_CODE (fndecl))
2089       {
2090       CASE_FLT_FN (BUILT_IN_SIN):
2091         builtin_optab = sin_optab; break;
2092       CASE_FLT_FN (BUILT_IN_COS):
2093         builtin_optab = cos_optab; break;
2094       default:
2095         gcc_unreachable ();
2096       }
2097
2098   /* Before working hard, check whether the instruction is available.  */
2099   if (optab_handler (builtin_optab, mode) != CODE_FOR_nothing)
2100     {
2101       rtx result = gen_reg_rtx (mode);
2102
2103       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2104          need to expand the argument again.  This way, we will not perform
2105          side-effects more the once.  */
2106       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2107
2108       op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
2109
2110       start_sequence ();
2111
2112       /* Compute into RESULT.
2113          Set RESULT to wherever the result comes back.  */
2114       if (builtin_optab == sincos_optab)
2115         {
2116           int ok;
2117
2118           switch (DECL_FUNCTION_CODE (fndecl))
2119             {
2120             CASE_FLT_FN (BUILT_IN_SIN):
2121               ok = expand_twoval_unop (builtin_optab, op0, 0, result, 0);
2122               break;
2123             CASE_FLT_FN (BUILT_IN_COS):
2124               ok = expand_twoval_unop (builtin_optab, op0, result, 0, 0);
2125               break;
2126             default:
2127               gcc_unreachable ();
2128             }
2129           gcc_assert (ok);
2130         }
2131       else
2132         result = expand_unop (mode, builtin_optab, op0, result, 0);
2133
2134       if (result != 0)
2135         {
2136           /* Output the entire sequence.  */
2137           insns = get_insns ();
2138           end_sequence ();
2139           emit_insn (insns);
2140           return result;
2141         }
2142
2143       /* If we were unable to expand via the builtin, stop the sequence
2144          (without outputting the insns) and call to the library function
2145          with the stabilized argument list.  */
2146       end_sequence ();
2147     }
2148
2149   return expand_call (exp, target, target == const0_rtx);
2150 }
2151
2152 /* Given an interclass math builtin decl FNDECL and it's argument ARG
2153    return an RTL instruction code that implements the functionality.
2154    If that isn't possible or available return CODE_FOR_nothing.  */
2155
2156 static enum insn_code
2157 interclass_mathfn_icode (tree arg, tree fndecl)
2158 {
2159   bool errno_set = false;
2160   optab builtin_optab = unknown_optab;
2161   machine_mode mode;
2162
2163   switch (DECL_FUNCTION_CODE (fndecl))
2164     {
2165     CASE_FLT_FN (BUILT_IN_ILOGB):
2166       errno_set = true; builtin_optab = ilogb_optab; break;
2167     CASE_FLT_FN (BUILT_IN_ISINF):
2168       builtin_optab = isinf_optab; break;
2169     case BUILT_IN_ISNORMAL:
2170     case BUILT_IN_ISFINITE:
2171     CASE_FLT_FN (BUILT_IN_FINITE):
2172     case BUILT_IN_FINITED32:
2173     case BUILT_IN_FINITED64:
2174     case BUILT_IN_FINITED128:
2175     case BUILT_IN_ISINFD32:
2176     case BUILT_IN_ISINFD64:
2177     case BUILT_IN_ISINFD128:
2178       /* These builtins have no optabs (yet).  */
2179       break;
2180     default:
2181       gcc_unreachable ();
2182     }
2183
2184   /* There's no easy way to detect the case we need to set EDOM.  */
2185   if (flag_errno_math && errno_set)
2186     return CODE_FOR_nothing;
2187
2188   /* Optab mode depends on the mode of the input argument.  */
2189   mode = TYPE_MODE (TREE_TYPE (arg));
2190
2191   if (builtin_optab)
2192     return optab_handler (builtin_optab, mode);
2193   return CODE_FOR_nothing;
2194 }
2195
2196 /* Expand a call to one of the builtin math functions that operate on
2197    floating point argument and output an integer result (ilogb, isinf,
2198    isnan, etc).
2199    Return 0 if a normal call should be emitted rather than expanding the
2200    function in-line.  EXP is the expression that is a call to the builtin
2201    function; if convenient, the result should be placed in TARGET.  */
2202
2203 static rtx
2204 expand_builtin_interclass_mathfn (tree exp, rtx target)
2205 {
2206   enum insn_code icode = CODE_FOR_nothing;
2207   rtx op0;
2208   tree fndecl = get_callee_fndecl (exp);
2209   machine_mode mode;
2210   tree arg;
2211
2212   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2213     return NULL_RTX;
2214
2215   arg = CALL_EXPR_ARG (exp, 0);
2216   icode = interclass_mathfn_icode (arg, fndecl);
2217   mode = TYPE_MODE (TREE_TYPE (arg));
2218
2219   if (icode != CODE_FOR_nothing)
2220     {
2221       struct expand_operand ops[1];
2222       rtx_insn *last = get_last_insn ();
2223       tree orig_arg = arg;
2224
2225       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2226          need to expand the argument again.  This way, we will not perform
2227          side-effects more the once.  */
2228       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2229
2230       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2231
2232       if (mode != GET_MODE (op0))
2233         op0 = convert_to_mode (mode, op0, 0);
2234
2235       create_output_operand (&ops[0], target, TYPE_MODE (TREE_TYPE (exp)));
2236       if (maybe_legitimize_operands (icode, 0, 1, ops)
2237           && maybe_emit_unop_insn (icode, ops[0].value, op0, UNKNOWN))
2238         return ops[0].value;
2239
2240       delete_insns_since (last);
2241       CALL_EXPR_ARG (exp, 0) = orig_arg;
2242     }
2243
2244   return NULL_RTX;
2245 }
2246
2247 /* Expand a call to the builtin sincos math function.
2248    Return NULL_RTX if a normal call should be emitted rather than expanding the
2249    function in-line.  EXP is the expression that is a call to the builtin
2250    function.  */
2251
2252 static rtx
2253 expand_builtin_sincos (tree exp)
2254 {
2255   rtx op0, op1, op2, target1, target2;
2256   machine_mode mode;
2257   tree arg, sinp, cosp;
2258   int result;
2259   location_t loc = EXPR_LOCATION (exp);
2260   tree alias_type, alias_off;
2261
2262   if (!validate_arglist (exp, REAL_TYPE,
2263                          POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
2264     return NULL_RTX;
2265
2266   arg = CALL_EXPR_ARG (exp, 0);
2267   sinp = CALL_EXPR_ARG (exp, 1);
2268   cosp = CALL_EXPR_ARG (exp, 2);
2269
2270   /* Make a suitable register to place result in.  */
2271   mode = TYPE_MODE (TREE_TYPE (arg));
2272
2273   /* Check if sincos insn is available, otherwise emit the call.  */
2274   if (optab_handler (sincos_optab, mode) == CODE_FOR_nothing)
2275     return NULL_RTX;
2276
2277   target1 = gen_reg_rtx (mode);
2278   target2 = gen_reg_rtx (mode);
2279
2280   op0 = expand_normal (arg);
2281   alias_type = build_pointer_type_for_mode (TREE_TYPE (arg), ptr_mode, true);
2282   alias_off = build_int_cst (alias_type, 0);
2283   op1 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2284                                         sinp, alias_off));
2285   op2 = expand_normal (fold_build2_loc (loc, MEM_REF, TREE_TYPE (arg),
2286                                         cosp, alias_off));
2287
2288   /* Compute into target1 and target2.
2289      Set TARGET to wherever the result comes back.  */
2290   result = expand_twoval_unop (sincos_optab, op0, target2, target1, 0);
2291   gcc_assert (result);
2292
2293   /* Move target1 and target2 to the memory locations indicated
2294      by op1 and op2.  */
2295   emit_move_insn (op1, target1);
2296   emit_move_insn (op2, target2);
2297
2298   return const0_rtx;
2299 }
2300
2301 /* Expand a call to the internal cexpi builtin to the sincos math function.
2302    EXP is the expression that is a call to the builtin function; if convenient,
2303    the result should be placed in TARGET.  */
2304
2305 static rtx
2306 expand_builtin_cexpi (tree exp, rtx target)
2307 {
2308   tree fndecl = get_callee_fndecl (exp);
2309   tree arg, type;
2310   machine_mode mode;
2311   rtx op0, op1, op2;
2312   location_t loc = EXPR_LOCATION (exp);
2313
2314   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2315     return NULL_RTX;
2316
2317   arg = CALL_EXPR_ARG (exp, 0);
2318   type = TREE_TYPE (arg);
2319   mode = TYPE_MODE (TREE_TYPE (arg));
2320
2321   /* Try expanding via a sincos optab, fall back to emitting a libcall
2322      to sincos or cexp.  We are sure we have sincos or cexp because cexpi
2323      is only generated from sincos, cexp or if we have either of them.  */
2324   if (optab_handler (sincos_optab, mode) != CODE_FOR_nothing)
2325     {
2326       op1 = gen_reg_rtx (mode);
2327       op2 = gen_reg_rtx (mode);
2328
2329       op0 = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
2330
2331       /* Compute into op1 and op2.  */
2332       expand_twoval_unop (sincos_optab, op0, op2, op1, 0);
2333     }
2334   else if (targetm.libc_has_function (function_sincos))
2335     {
2336       tree call, fn = NULL_TREE;
2337       tree top1, top2;
2338       rtx op1a, op2a;
2339
2340       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2341         fn = builtin_decl_explicit (BUILT_IN_SINCOSF);
2342       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2343         fn = builtin_decl_explicit (BUILT_IN_SINCOS);
2344       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2345         fn = builtin_decl_explicit (BUILT_IN_SINCOSL);
2346       else
2347         gcc_unreachable ();
2348
2349       op1 = assign_temp (TREE_TYPE (arg), 1, 1);
2350       op2 = assign_temp (TREE_TYPE (arg), 1, 1);
2351       op1a = copy_addr_to_reg (XEXP (op1, 0));
2352       op2a = copy_addr_to_reg (XEXP (op2, 0));
2353       top1 = make_tree (build_pointer_type (TREE_TYPE (arg)), op1a);
2354       top2 = make_tree (build_pointer_type (TREE_TYPE (arg)), op2a);
2355
2356       /* Make sure not to fold the sincos call again.  */
2357       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2358       expand_normal (build_call_nary (TREE_TYPE (TREE_TYPE (fn)),
2359                                       call, 3, arg, top1, top2));
2360     }
2361   else
2362     {
2363       tree call, fn = NULL_TREE, narg;
2364       tree ctype = build_complex_type (type);
2365
2366       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2367         fn = builtin_decl_explicit (BUILT_IN_CEXPF);
2368       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2369         fn = builtin_decl_explicit (BUILT_IN_CEXP);
2370       else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2371         fn = builtin_decl_explicit (BUILT_IN_CEXPL);
2372       else
2373         gcc_unreachable ();
2374
2375       /* If we don't have a decl for cexp create one.  This is the
2376          friendliest fallback if the user calls __builtin_cexpi
2377          without full target C99 function support.  */
2378       if (fn == NULL_TREE)
2379         {
2380           tree fntype;
2381           const char *name = NULL;
2382
2383           if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIF)
2384             name = "cexpf";
2385           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPI)
2386             name = "cexp";
2387           else if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CEXPIL)
2388             name = "cexpl";
2389
2390           fntype = build_function_type_list (ctype, ctype, NULL_TREE);
2391           fn = build_fn_decl (name, fntype);
2392         }
2393
2394       narg = fold_build2_loc (loc, COMPLEX_EXPR, ctype,
2395                           build_real (type, dconst0), arg);
2396
2397       /* Make sure not to fold the cexp call again.  */
2398       call = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (fn)), fn);
2399       return expand_expr (build_call_nary (ctype, call, 1, narg),
2400                           target, VOIDmode, EXPAND_NORMAL);
2401     }
2402
2403   /* Now build the proper return type.  */
2404   return expand_expr (build2 (COMPLEX_EXPR, build_complex_type (type),
2405                               make_tree (TREE_TYPE (arg), op2),
2406                               make_tree (TREE_TYPE (arg), op1)),
2407                       target, VOIDmode, EXPAND_NORMAL);
2408 }
2409
2410 /* Conveniently construct a function call expression.  FNDECL names the
2411    function to be called, N is the number of arguments, and the "..."
2412    parameters are the argument expressions.  Unlike build_call_exr
2413    this doesn't fold the call, hence it will always return a CALL_EXPR.  */
2414
2415 static tree
2416 build_call_nofold_loc (location_t loc, tree fndecl, int n, ...)
2417 {
2418   va_list ap;
2419   tree fntype = TREE_TYPE (fndecl);
2420   tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl);
2421
2422   va_start (ap, n);
2423   fn = build_call_valist (TREE_TYPE (fntype), fn, n, ap);
2424   va_end (ap);
2425   SET_EXPR_LOCATION (fn, loc);
2426   return fn;
2427 }
2428
2429 /* Expand a call to one of the builtin rounding functions gcc defines
2430    as an extension (lfloor and lceil).  As these are gcc extensions we
2431    do not need to worry about setting errno to EDOM.
2432    If expanding via optab fails, lower expression to (int)(floor(x)).
2433    EXP is the expression that is a call to the builtin function;
2434    if convenient, the result should be placed in TARGET.  */
2435
2436 static rtx
2437 expand_builtin_int_roundingfn (tree exp, rtx target)
2438 {
2439   convert_optab builtin_optab;
2440   rtx op0, tmp;
2441   rtx_insn *insns;
2442   tree fndecl = get_callee_fndecl (exp);
2443   enum built_in_function fallback_fn;
2444   tree fallback_fndecl;
2445   machine_mode mode;
2446   tree arg;
2447
2448   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2449     gcc_unreachable ();
2450
2451   arg = CALL_EXPR_ARG (exp, 0);
2452
2453   switch (DECL_FUNCTION_CODE (fndecl))
2454     {
2455     CASE_FLT_FN (BUILT_IN_ICEIL):
2456     CASE_FLT_FN (BUILT_IN_LCEIL):
2457     CASE_FLT_FN (BUILT_IN_LLCEIL):
2458       builtin_optab = lceil_optab;
2459       fallback_fn = BUILT_IN_CEIL;
2460       break;
2461
2462     CASE_FLT_FN (BUILT_IN_IFLOOR):
2463     CASE_FLT_FN (BUILT_IN_LFLOOR):
2464     CASE_FLT_FN (BUILT_IN_LLFLOOR):
2465       builtin_optab = lfloor_optab;
2466       fallback_fn = BUILT_IN_FLOOR;
2467       break;
2468
2469     default:
2470       gcc_unreachable ();
2471     }
2472
2473   /* Make a suitable register to place result in.  */
2474   mode = TYPE_MODE (TREE_TYPE (exp));
2475
2476   target = gen_reg_rtx (mode);
2477
2478   /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2479      need to expand the argument again.  This way, we will not perform
2480      side-effects more the once.  */
2481   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2482
2483   op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2484
2485   start_sequence ();
2486
2487   /* Compute into TARGET.  */
2488   if (expand_sfix_optab (target, op0, builtin_optab))
2489     {
2490       /* Output the entire sequence.  */
2491       insns = get_insns ();
2492       end_sequence ();
2493       emit_insn (insns);
2494       return target;
2495     }
2496
2497   /* If we were unable to expand via the builtin, stop the sequence
2498      (without outputting the insns).  */
2499   end_sequence ();
2500
2501   /* Fall back to floating point rounding optab.  */
2502   fallback_fndecl = mathfn_built_in (TREE_TYPE (arg), fallback_fn);
2503
2504   /* For non-C99 targets we may end up without a fallback fndecl here
2505      if the user called __builtin_lfloor directly.  In this case emit
2506      a call to the floor/ceil variants nevertheless.  This should result
2507      in the best user experience for not full C99 targets.  */
2508   if (fallback_fndecl == NULL_TREE)
2509     {
2510       tree fntype;
2511       const char *name = NULL;
2512
2513       switch (DECL_FUNCTION_CODE (fndecl))
2514         {
2515         case BUILT_IN_ICEIL:
2516         case BUILT_IN_LCEIL:
2517         case BUILT_IN_LLCEIL:
2518           name = "ceil";
2519           break;
2520         case BUILT_IN_ICEILF:
2521         case BUILT_IN_LCEILF:
2522         case BUILT_IN_LLCEILF:
2523           name = "ceilf";
2524           break;
2525         case BUILT_IN_ICEILL:
2526         case BUILT_IN_LCEILL:
2527         case BUILT_IN_LLCEILL:
2528           name = "ceill";
2529           break;
2530         case BUILT_IN_IFLOOR:
2531         case BUILT_IN_LFLOOR:
2532         case BUILT_IN_LLFLOOR:
2533           name = "floor";
2534           break;
2535         case BUILT_IN_IFLOORF:
2536         case BUILT_IN_LFLOORF:
2537         case BUILT_IN_LLFLOORF:
2538           name = "floorf";
2539           break;
2540         case BUILT_IN_IFLOORL:
2541         case BUILT_IN_LFLOORL:
2542         case BUILT_IN_LLFLOORL:
2543           name = "floorl";
2544           break;
2545         default:
2546           gcc_unreachable ();
2547         }
2548
2549       fntype = build_function_type_list (TREE_TYPE (arg),
2550                                          TREE_TYPE (arg), NULL_TREE);
2551       fallback_fndecl = build_fn_decl (name, fntype);
2552     }
2553
2554   exp = build_call_nofold_loc (EXPR_LOCATION (exp), fallback_fndecl, 1, arg);
2555
2556   tmp = expand_normal (exp);
2557   tmp = maybe_emit_group_store (tmp, TREE_TYPE (exp));
2558
2559   /* Truncate the result of floating point optab to integer
2560      via expand_fix ().  */
2561   target = gen_reg_rtx (mode);
2562   expand_fix (target, tmp, 0);
2563
2564   return target;
2565 }
2566
2567 /* Expand a call to one of the builtin math functions doing integer
2568    conversion (lrint).
2569    Return 0 if a normal call should be emitted rather than expanding the
2570    function in-line.  EXP is the expression that is a call to the builtin
2571    function; if convenient, the result should be placed in TARGET.  */
2572
2573 static rtx
2574 expand_builtin_int_roundingfn_2 (tree exp, rtx target)
2575 {
2576   convert_optab builtin_optab;
2577   rtx op0;
2578   rtx_insn *insns;
2579   tree fndecl = get_callee_fndecl (exp);
2580   tree arg;
2581   machine_mode mode;
2582   enum built_in_function fallback_fn = BUILT_IN_NONE;
2583
2584   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
2585      gcc_unreachable ();
2586
2587   arg = CALL_EXPR_ARG (exp, 0);
2588
2589   switch (DECL_FUNCTION_CODE (fndecl))
2590     {
2591     CASE_FLT_FN (BUILT_IN_IRINT):
2592       fallback_fn = BUILT_IN_LRINT;
2593       /* FALLTHRU */
2594     CASE_FLT_FN (BUILT_IN_LRINT):
2595     CASE_FLT_FN (BUILT_IN_LLRINT):
2596       builtin_optab = lrint_optab;
2597       break;
2598
2599     CASE_FLT_FN (BUILT_IN_IROUND):
2600       fallback_fn = BUILT_IN_LROUND;
2601       /* FALLTHRU */
2602     CASE_FLT_FN (BUILT_IN_LROUND):
2603     CASE_FLT_FN (BUILT_IN_LLROUND):
2604       builtin_optab = lround_optab;
2605       break;
2606
2607     default:
2608       gcc_unreachable ();
2609     }
2610
2611   /* There's no easy way to detect the case we need to set EDOM.  */
2612   if (flag_errno_math && fallback_fn == BUILT_IN_NONE)
2613     return NULL_RTX;
2614
2615   /* Make a suitable register to place result in.  */
2616   mode = TYPE_MODE (TREE_TYPE (exp));
2617
2618   /* There's no easy way to detect the case we need to set EDOM.  */
2619   if (!flag_errno_math)
2620     {
2621       rtx result = gen_reg_rtx (mode);
2622
2623       /* Wrap the computation of the argument in a SAVE_EXPR, as we may
2624          need to expand the argument again.  This way, we will not perform
2625          side-effects more the once.  */
2626       CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
2627
2628       op0 = expand_expr (arg, NULL, VOIDmode, EXPAND_NORMAL);
2629
2630       start_sequence ();
2631
2632       if (expand_sfix_optab (result, op0, builtin_optab))
2633         {
2634           /* Output the entire sequence.  */
2635           insns = get_insns ();
2636           end_sequence ();
2637           emit_insn (insns);
2638           return result;
2639         }
2640
2641       /* If we were unable to expand via the builtin, stop the sequence
2642          (without outputting the insns) and call to the library function
2643          with the stabilized argument list.  */
2644       end_sequence ();
2645     }
2646
2647   if (fallback_fn != BUILT_IN_NONE)
2648     {
2649       /* Fall back to rounding to long int.  Use implicit_p 0 - for non-C99
2650          targets, (int) round (x) should never be transformed into
2651          BUILT_IN_IROUND and if __builtin_iround is called directly, emit
2652          a call to lround in the hope that the target provides at least some
2653          C99 functions.  This should result in the best user experience for
2654          not full C99 targets.  */
2655       tree fallback_fndecl = mathfn_built_in_1
2656         (TREE_TYPE (arg), as_combined_fn (fallback_fn), 0);
2657
2658       exp = build_call_nofold_loc (EXPR_LOCATION (exp),
2659                                    fallback_fndecl, 1, arg);
2660
2661       target = expand_call (exp, NULL_RTX, target == const0_rtx);
2662       target = maybe_emit_group_store (target, TREE_TYPE (exp));
2663       return convert_to_mode (mode, target, 0);
2664     }
2665
2666   return expand_call (exp, target, target == const0_rtx);
2667 }
2668
2669 /* Expand a call to the powi built-in mathematical function.  Return NULL_RTX if
2670    a normal call should be emitted rather than expanding the function
2671    in-line.  EXP is the expression that is a call to the builtin
2672    function; if convenient, the result should be placed in TARGET.  */
2673
2674 static rtx
2675 expand_builtin_powi (tree exp, rtx target)
2676 {
2677   tree arg0, arg1;
2678   rtx op0, op1;
2679   machine_mode mode;
2680   machine_mode mode2;
2681
2682   if (! validate_arglist (exp, REAL_TYPE, INTEGER_TYPE, VOID_TYPE))
2683     return NULL_RTX;
2684
2685   arg0 = CALL_EXPR_ARG (exp, 0);
2686   arg1 = CALL_EXPR_ARG (exp, 1);
2687   mode = TYPE_MODE (TREE_TYPE (exp));
2688
2689   /* Emit a libcall to libgcc.  */
2690
2691   /* Mode of the 2nd argument must match that of an int.  */
2692   mode2 = mode_for_size (INT_TYPE_SIZE, MODE_INT, 0);
2693
2694   if (target == NULL_RTX)
2695     target = gen_reg_rtx (mode);
2696
2697   op0 = expand_expr (arg0, NULL_RTX, mode, EXPAND_NORMAL);
2698   if (GET_MODE (op0) != mode)
2699     op0 = convert_to_mode (mode, op0, 0);
2700   op1 = expand_expr (arg1, NULL_RTX, mode2, EXPAND_NORMAL);
2701   if (GET_MODE (op1) != mode2)
2702     op1 = convert_to_mode (mode2, op1, 0);
2703
2704   target = emit_library_call_value (optab_libfunc (powi_optab, mode),
2705                                     target, LCT_CONST, mode, 2,
2706                                     op0, mode, op1, mode2);
2707
2708   return target;
2709 }
2710
2711 /* Expand expression EXP which is a call to the strlen builtin.  Return
2712    NULL_RTX if we failed the caller should emit a normal call, otherwise
2713    try to get the result in TARGET, if convenient.  */
2714
2715 static rtx
2716 expand_builtin_strlen (tree exp, rtx target,
2717                        machine_mode target_mode)
2718 {
2719   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
2720     return NULL_RTX;
2721   else
2722     {
2723       struct expand_operand ops[4];
2724       rtx pat;
2725       tree len;
2726       tree src = CALL_EXPR_ARG (exp, 0);
2727       rtx src_reg;
2728       rtx_insn *before_strlen;
2729       machine_mode insn_mode = target_mode;
2730       enum insn_code icode = CODE_FOR_nothing;
2731       unsigned int align;
2732
2733       /* If the length can be computed at compile-time, return it.  */
2734       len = c_strlen (src, 0);
2735       if (len)
2736         return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2737
2738       /* If the length can be computed at compile-time and is constant
2739          integer, but there are side-effects in src, evaluate
2740          src for side-effects, then return len.
2741          E.g. x = strlen (i++ ? "xfoo" + 1 : "bar");
2742          can be optimized into: i++; x = 3;  */
2743       len = c_strlen (src, 1);
2744       if (len && TREE_CODE (len) == INTEGER_CST)
2745         {
2746           expand_expr (src, const0_rtx, VOIDmode, EXPAND_NORMAL);
2747           return expand_expr (len, target, target_mode, EXPAND_NORMAL);
2748         }
2749
2750       align = get_pointer_alignment (src) / BITS_PER_UNIT;
2751
2752       /* If SRC is not a pointer type, don't do this operation inline.  */
2753       if (align == 0)
2754         return NULL_RTX;
2755
2756       /* Bail out if we can't compute strlen in the right mode.  */
2757       while (insn_mode != VOIDmode)
2758         {
2759           icode = optab_handler (strlen_optab, insn_mode);
2760           if (icode != CODE_FOR_nothing)
2761             break;
2762
2763           insn_mode = GET_MODE_WIDER_MODE (insn_mode);
2764         }
2765       if (insn_mode == VOIDmode)
2766         return NULL_RTX;
2767
2768       /* Make a place to hold the source address.  We will not expand
2769          the actual source until we are sure that the expansion will
2770          not fail -- there are trees that cannot be expanded twice.  */
2771       src_reg = gen_reg_rtx (Pmode);
2772
2773       /* Mark the beginning of the strlen sequence so we can emit the
2774          source operand later.  */
2775       before_strlen = get_last_insn ();
2776
2777       create_output_operand (&ops[0], target, insn_mode);
2778       create_fixed_operand (&ops[1], gen_rtx_MEM (BLKmode, src_reg));
2779       create_integer_operand (&ops[2], 0);
2780       create_integer_operand (&ops[3], align);
2781       if (!maybe_expand_insn (icode, 4, ops))
2782         return NULL_RTX;
2783
2784       /* Now that we are assured of success, expand the source.  */
2785       start_sequence ();
2786       pat = expand_expr (src, src_reg, Pmode, EXPAND_NORMAL);
2787       if (pat != src_reg)
2788         {
2789 #ifdef POINTERS_EXTEND_UNSIGNED
2790           if (GET_MODE (pat) != Pmode)
2791             pat = convert_to_mode (Pmode, pat,
2792                                    POINTERS_EXTEND_UNSIGNED);
2793 #endif
2794           emit_move_insn (src_reg, pat);
2795         }
2796       pat = get_insns ();
2797       end_sequence ();
2798
2799       if (before_strlen)
2800         emit_insn_after (pat, before_strlen);
2801       else
2802         emit_insn_before (pat, get_insns ());
2803
2804       /* Return the value in the proper mode for this function.  */
2805       if (GET_MODE (ops[0].value) == target_mode)
2806         target = ops[0].value;
2807       else if (target != 0)
2808         convert_move (target, ops[0].value, 0);
2809       else
2810         target = convert_to_mode (target_mode, ops[0].value, 0);
2811
2812       return target;
2813     }
2814 }
2815
2816 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
2817    bytes from constant string DATA + OFFSET and return it as target
2818    constant.  */
2819
2820 static rtx
2821 builtin_memcpy_read_str (void *data, HOST_WIDE_INT offset,
2822                          machine_mode mode)
2823 {
2824   const char *str = (const char *) data;
2825
2826   gcc_assert (offset >= 0
2827               && ((unsigned HOST_WIDE_INT) offset + GET_MODE_SIZE (mode)
2828                   <= strlen (str) + 1));
2829
2830   return c_readstr (str + offset, mode);
2831 }
2832
2833 /* LEN specify length of the block of memcpy/memset operation.
2834    Figure out its range and put it into MIN_SIZE/MAX_SIZE.
2835    In some cases we can make very likely guess on max size, then we
2836    set it into PROBABLE_MAX_SIZE.  */
2837
2838 static void
2839 determine_block_size (tree len, rtx len_rtx,
2840                       unsigned HOST_WIDE_INT *min_size,
2841                       unsigned HOST_WIDE_INT *max_size,
2842                       unsigned HOST_WIDE_INT *probable_max_size)
2843 {
2844   if (CONST_INT_P (len_rtx))
2845     {
2846       *min_size = *max_size = *probable_max_size = UINTVAL (len_rtx);
2847       return;
2848     }
2849   else
2850     {
2851       wide_int min, max;
2852       enum value_range_type range_type = VR_UNDEFINED;
2853
2854       /* Determine bounds from the type.  */
2855       if (tree_fits_uhwi_p (TYPE_MIN_VALUE (TREE_TYPE (len))))
2856         *min_size = tree_to_uhwi (TYPE_MIN_VALUE (TREE_TYPE (len)));
2857       else
2858         *min_size = 0;
2859       if (tree_fits_uhwi_p (TYPE_MAX_VALUE (TREE_TYPE (len))))
2860         *probable_max_size = *max_size
2861           = tree_to_uhwi (TYPE_MAX_VALUE (TREE_TYPE (len)));
2862       else
2863         *probable_max_size = *max_size = GET_MODE_MASK (GET_MODE (len_rtx));
2864
2865       if (TREE_CODE (len) == SSA_NAME)
2866         range_type = get_range_info (len, &min, &max);
2867       if (range_type == VR_RANGE)
2868         {
2869           if (wi::fits_uhwi_p (min) && *min_size < min.to_uhwi ())
2870             *min_size = min.to_uhwi ();
2871           if (wi::fits_uhwi_p (max) && *max_size > max.to_uhwi ())
2872             *probable_max_size = *max_size = max.to_uhwi ();
2873         }
2874       else if (range_type == VR_ANTI_RANGE)
2875         {
2876           /* Anti range 0...N lets us to determine minimal size to N+1.  */
2877           if (min == 0)
2878             {
2879               if (wi::fits_uhwi_p (max) && max.to_uhwi () + 1 != 0)
2880                 *min_size = max.to_uhwi () + 1;
2881             }
2882           /* Code like
2883
2884              int n;
2885              if (n < 100)
2886                memcpy (a, b, n)
2887
2888              Produce anti range allowing negative values of N.  We still
2889              can use the information and make a guess that N is not negative.
2890              */
2891           else if (!wi::leu_p (max, 1 << 30) && wi::fits_uhwi_p (min))
2892             *probable_max_size = min.to_uhwi () - 1;
2893         }
2894     }
2895   gcc_checking_assert (*max_size <=
2896                        (unsigned HOST_WIDE_INT)
2897                           GET_MODE_MASK (GET_MODE (len_rtx)));
2898 }
2899
2900 /* Helper function to do the actual work for expand_builtin_memcpy.  */
2901
2902 static rtx
2903 expand_builtin_memcpy_args (tree dest, tree src, tree len, rtx target, tree exp)
2904 {
2905   const char *src_str;
2906   unsigned int src_align = get_pointer_alignment (src);
2907   unsigned int dest_align = get_pointer_alignment (dest);
2908   rtx dest_mem, src_mem, dest_addr, len_rtx;
2909   HOST_WIDE_INT expected_size = -1;
2910   unsigned int expected_align = 0;
2911   unsigned HOST_WIDE_INT min_size;
2912   unsigned HOST_WIDE_INT max_size;
2913   unsigned HOST_WIDE_INT probable_max_size;
2914
2915   /* If DEST is not a pointer type, call the normal function.  */
2916   if (dest_align == 0)
2917     return NULL_RTX;
2918
2919   /* If either SRC is not a pointer type, don't do this
2920      operation in-line.  */
2921   if (src_align == 0)
2922     return NULL_RTX;
2923
2924   if (currently_expanding_gimple_stmt)
2925     stringop_block_profile (currently_expanding_gimple_stmt,
2926                             &expected_align, &expected_size);
2927
2928   if (expected_align < dest_align)
2929     expected_align = dest_align;
2930   dest_mem = get_memory_rtx (dest, len);
2931   set_mem_align (dest_mem, dest_align);
2932   len_rtx = expand_normal (len);
2933   determine_block_size (len, len_rtx, &min_size, &max_size,
2934                         &probable_max_size);
2935   src_str = c_getstr (src);
2936
2937   /* If SRC is a string constant and block move would be done
2938      by pieces, we can avoid loading the string from memory
2939      and only stored the computed constants.  */
2940   if (src_str
2941       && CONST_INT_P (len_rtx)
2942       && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
2943       && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
2944                               CONST_CAST (char *, src_str),
2945                               dest_align, false))
2946     {
2947       dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
2948                                   builtin_memcpy_read_str,
2949                                   CONST_CAST (char *, src_str),
2950                                   dest_align, false, 0);
2951       dest_mem = force_operand (XEXP (dest_mem, 0), target);
2952       dest_mem = convert_memory_address (ptr_mode, dest_mem);
2953       return dest_mem;
2954     }
2955
2956   src_mem = get_memory_rtx (src, len);
2957   set_mem_align (src_mem, src_align);
2958
2959   /* Copy word part most expediently.  */
2960   dest_addr = emit_block_move_hints (dest_mem, src_mem, len_rtx,
2961                                      CALL_EXPR_TAILCALL (exp)
2962                                      ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
2963                                      expected_align, expected_size,
2964                                      min_size, max_size, probable_max_size);
2965
2966   if (dest_addr == 0)
2967     {
2968       dest_addr = force_operand (XEXP (dest_mem, 0), target);
2969       dest_addr = convert_memory_address (ptr_mode, dest_addr);
2970     }
2971
2972   return dest_addr;
2973 }
2974
2975 /* Expand a call EXP to the memcpy builtin.
2976    Return NULL_RTX if we failed, the caller should emit a normal call,
2977    otherwise try to get the result in TARGET, if convenient (and in
2978    mode MODE if that's convenient).  */
2979
2980 static rtx
2981 expand_builtin_memcpy (tree exp, rtx target)
2982 {
2983   if (!validate_arglist (exp,
2984                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
2985     return NULL_RTX;
2986   else
2987     {
2988       tree dest = CALL_EXPR_ARG (exp, 0);
2989       tree src = CALL_EXPR_ARG (exp, 1);
2990       tree len = CALL_EXPR_ARG (exp, 2);
2991       return expand_builtin_memcpy_args (dest, src, len, target, exp);
2992     }
2993 }
2994
2995 /* Expand an instrumented call EXP to the memcpy builtin.
2996    Return NULL_RTX if we failed, the caller should emit a normal call,
2997    otherwise try to get the result in TARGET, if convenient (and in
2998    mode MODE if that's convenient).  */
2999
3000 static rtx
3001 expand_builtin_memcpy_with_bounds (tree exp, rtx target)
3002 {
3003   if (!validate_arglist (exp,
3004                          POINTER_TYPE, POINTER_BOUNDS_TYPE,
3005                          POINTER_TYPE, POINTER_BOUNDS_TYPE,
3006                          INTEGER_TYPE, VOID_TYPE))
3007     return NULL_RTX;
3008   else
3009     {
3010       tree dest = CALL_EXPR_ARG (exp, 0);
3011       tree src = CALL_EXPR_ARG (exp, 2);
3012       tree len = CALL_EXPR_ARG (exp, 4);
3013       rtx res = expand_builtin_memcpy_args (dest, src, len, target, exp);
3014
3015       /* Return src bounds with the result.  */
3016       if (res)
3017         {
3018           rtx bnd = force_reg (targetm.chkp_bound_mode (),
3019                                expand_normal (CALL_EXPR_ARG (exp, 1)));
3020           res = chkp_join_splitted_slot (res, bnd);
3021         }
3022       return res;
3023     }
3024 }
3025
3026 /* Expand a call EXP to the mempcpy builtin.
3027    Return NULL_RTX if we failed; the caller should emit a normal call,
3028    otherwise try to get the result in TARGET, if convenient (and in
3029    mode MODE if that's convenient).  If ENDP is 0 return the
3030    destination pointer, if ENDP is 1 return the end pointer ala
3031    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3032    stpcpy.  */
3033
3034 static rtx
3035 expand_builtin_mempcpy (tree exp, rtx target, machine_mode mode)
3036 {
3037   if (!validate_arglist (exp,
3038                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3039     return NULL_RTX;
3040   else
3041     {
3042       tree dest = CALL_EXPR_ARG (exp, 0);
3043       tree src = CALL_EXPR_ARG (exp, 1);
3044       tree len = CALL_EXPR_ARG (exp, 2);
3045       return expand_builtin_mempcpy_args (dest, src, len,
3046                                           target, mode, /*endp=*/ 1,
3047                                           exp);
3048     }
3049 }
3050
3051 /* Expand an instrumented call EXP to the mempcpy builtin.
3052    Return NULL_RTX if we failed, the caller should emit a normal call,
3053    otherwise try to get the result in TARGET, if convenient (and in
3054    mode MODE if that's convenient).  */
3055
3056 static rtx
3057 expand_builtin_mempcpy_with_bounds (tree exp, rtx target, machine_mode mode)
3058 {
3059   if (!validate_arglist (exp,
3060                          POINTER_TYPE, POINTER_BOUNDS_TYPE,
3061                          POINTER_TYPE, POINTER_BOUNDS_TYPE,
3062                          INTEGER_TYPE, VOID_TYPE))
3063     return NULL_RTX;
3064   else
3065     {
3066       tree dest = CALL_EXPR_ARG (exp, 0);
3067       tree src = CALL_EXPR_ARG (exp, 2);
3068       tree len = CALL_EXPR_ARG (exp, 4);
3069       rtx res = expand_builtin_mempcpy_args (dest, src, len, target,
3070                                              mode, 1, exp);
3071
3072       /* Return src bounds with the result.  */
3073       if (res)
3074         {
3075           rtx bnd = force_reg (targetm.chkp_bound_mode (),
3076                                expand_normal (CALL_EXPR_ARG (exp, 1)));
3077           res = chkp_join_splitted_slot (res, bnd);
3078         }
3079       return res;
3080     }
3081 }
3082
3083 /* Helper function to do the actual work for expand_builtin_mempcpy.  The
3084    arguments to the builtin_mempcpy call DEST, SRC, and LEN are broken out
3085    so that this can also be called without constructing an actual CALL_EXPR.
3086    The other arguments and return value are the same as for
3087    expand_builtin_mempcpy.  */
3088
3089 static rtx
3090 expand_builtin_mempcpy_args (tree dest, tree src, tree len,
3091                              rtx target, machine_mode mode, int endp,
3092                              tree orig_exp)
3093 {
3094   tree fndecl = get_callee_fndecl (orig_exp);
3095
3096     /* If return value is ignored, transform mempcpy into memcpy.  */
3097   if (target == const0_rtx
3098       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK_CHKP
3099       && builtin_decl_implicit_p (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP))
3100     {
3101       tree fn = builtin_decl_implicit (BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP);
3102       tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3103                                            dest, src, len);
3104       return expand_expr (result, target, mode, EXPAND_NORMAL);
3105     }
3106   else if (target == const0_rtx
3107            && builtin_decl_implicit_p (BUILT_IN_MEMCPY))
3108     {
3109       tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY);
3110       tree result = build_call_nofold_loc (UNKNOWN_LOCATION, fn, 3,
3111                                            dest, src, len);
3112       return expand_expr (result, target, mode, EXPAND_NORMAL);
3113     }
3114   else
3115     {
3116       const char *src_str;
3117       unsigned int src_align = get_pointer_alignment (src);
3118       unsigned int dest_align = get_pointer_alignment (dest);
3119       rtx dest_mem, src_mem, len_rtx;
3120
3121       /* If either SRC or DEST is not a pointer type, don't do this
3122          operation in-line.  */
3123       if (dest_align == 0 || src_align == 0)
3124         return NULL_RTX;
3125
3126       /* If LEN is not constant, call the normal function.  */
3127       if (! tree_fits_uhwi_p (len))
3128         return NULL_RTX;
3129
3130       len_rtx = expand_normal (len);
3131       src_str = c_getstr (src);
3132
3133       /* If SRC is a string constant and block move would be done
3134          by pieces, we can avoid loading the string from memory
3135          and only stored the computed constants.  */
3136       if (src_str
3137           && CONST_INT_P (len_rtx)
3138           && (unsigned HOST_WIDE_INT) INTVAL (len_rtx) <= strlen (src_str) + 1
3139           && can_store_by_pieces (INTVAL (len_rtx), builtin_memcpy_read_str,
3140                                   CONST_CAST (char *, src_str),
3141                                   dest_align, false))
3142         {
3143           dest_mem = get_memory_rtx (dest, len);
3144           set_mem_align (dest_mem, dest_align);
3145           dest_mem = store_by_pieces (dest_mem, INTVAL (len_rtx),
3146                                       builtin_memcpy_read_str,
3147                                       CONST_CAST (char *, src_str),
3148                                       dest_align, false, endp);
3149           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3150           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3151           return dest_mem;
3152         }
3153
3154       if (CONST_INT_P (len_rtx)
3155           && can_move_by_pieces (INTVAL (len_rtx),
3156                                  MIN (dest_align, src_align)))
3157         {
3158           dest_mem = get_memory_rtx (dest, len);
3159           set_mem_align (dest_mem, dest_align);
3160           src_mem = get_memory_rtx (src, len);
3161           set_mem_align (src_mem, src_align);
3162           dest_mem = move_by_pieces (dest_mem, src_mem, INTVAL (len_rtx),
3163                                      MIN (dest_align, src_align), endp);
3164           dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3165           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3166           return dest_mem;
3167         }
3168
3169       return NULL_RTX;
3170     }
3171 }
3172
3173 /* Expand into a movstr instruction, if one is available.  Return NULL_RTX if
3174    we failed, the caller should emit a normal call, otherwise try to
3175    get the result in TARGET, if convenient.  If ENDP is 0 return the
3176    destination pointer, if ENDP is 1 return the end pointer ala
3177    mempcpy, and if ENDP is 2 return the end pointer minus one ala
3178    stpcpy.  */
3179
3180 static rtx
3181 expand_movstr (tree dest, tree src, rtx target, int endp)
3182 {
3183   struct expand_operand ops[3];
3184   rtx dest_mem;
3185   rtx src_mem;
3186
3187   if (!targetm.have_movstr ())
3188     return NULL_RTX;
3189
3190   dest_mem = get_memory_rtx (dest, NULL);
3191   src_mem = get_memory_rtx (src, NULL);
3192   if (!endp)
3193     {
3194       target = force_reg (Pmode, XEXP (dest_mem, 0));
3195       dest_mem = replace_equiv_address (dest_mem, target);
3196     }
3197
3198   create_output_operand (&ops[0], endp ? target : NULL_RTX, Pmode);
3199   create_fixed_operand (&ops[1], dest_mem);
3200   create_fixed_operand (&ops[2], src_mem);
3201   if (!maybe_expand_insn (targetm.code_for_movstr, 3, ops))
3202     return NULL_RTX;
3203
3204   if (endp && target != const0_rtx)
3205     {
3206       target = ops[0].value;
3207       /* movstr is supposed to set end to the address of the NUL
3208          terminator.  If the caller requested a mempcpy-like return value,
3209          adjust it.  */
3210       if (endp == 1)
3211         {
3212           rtx tem = plus_constant (GET_MODE (target),
3213                                    gen_lowpart (GET_MODE (target), target), 1);
3214           emit_move_insn (target, force_operand (tem, NULL_RTX));
3215         }
3216     }
3217   return target;
3218 }
3219
3220 /* Expand expression EXP, which is a call to the strcpy builtin.  Return
3221    NULL_RTX if we failed the caller should emit a normal call, otherwise
3222    try to get the result in TARGET, if convenient (and in mode MODE if that's
3223    convenient).  */
3224
3225 static rtx
3226 expand_builtin_strcpy (tree exp, rtx target)
3227 {
3228   if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3229    {
3230      tree dest = CALL_EXPR_ARG (exp, 0);
3231      tree src = CALL_EXPR_ARG (exp, 1);
3232      return expand_builtin_strcpy_args (dest, src, target);
3233    }
3234    return NULL_RTX;
3235 }
3236
3237 /* Helper function to do the actual work for expand_builtin_strcpy.  The
3238    arguments to the builtin_strcpy call DEST and SRC are broken out
3239    so that this can also be called without constructing an actual CALL_EXPR.
3240    The other arguments and return value are the same as for
3241    expand_builtin_strcpy.  */
3242
3243 static rtx
3244 expand_builtin_strcpy_args (tree dest, tree src, rtx target)
3245 {
3246   return expand_movstr (dest, src, target, /*endp=*/0);
3247 }
3248
3249 /* Expand a call EXP to the stpcpy builtin.
3250    Return NULL_RTX if we failed the caller should emit a normal call,
3251    otherwise try to get the result in TARGET, if convenient (and in
3252    mode MODE if that's convenient).  */
3253
3254 static rtx
3255 expand_builtin_stpcpy (tree exp, rtx target, machine_mode mode)
3256 {
3257   tree dst, src;
3258   location_t loc = EXPR_LOCATION (exp);
3259
3260   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3261     return NULL_RTX;
3262
3263   dst = CALL_EXPR_ARG (exp, 0);
3264   src = CALL_EXPR_ARG (exp, 1);
3265
3266   /* If return value is ignored, transform stpcpy into strcpy.  */
3267   if (target == const0_rtx && builtin_decl_implicit (BUILT_IN_STRCPY))
3268     {
3269       tree fn = builtin_decl_implicit (BUILT_IN_STRCPY);
3270       tree result = build_call_nofold_loc (loc, fn, 2, dst, src);
3271       return expand_expr (result, target, mode, EXPAND_NORMAL);
3272     }
3273   else
3274     {
3275       tree len, lenp1;
3276       rtx ret;
3277
3278       /* Ensure we get an actual string whose length can be evaluated at
3279          compile-time, not an expression containing a string.  This is
3280          because the latter will potentially produce pessimized code
3281          when used to produce the return value.  */
3282       if (! c_getstr (src) || ! (len = c_strlen (src, 0)))
3283         return expand_movstr (dst, src, target, /*endp=*/2);
3284
3285       lenp1 = size_binop_loc (loc, PLUS_EXPR, len, ssize_int (1));
3286       ret = expand_builtin_mempcpy_args (dst, src, lenp1,
3287                                          target, mode, /*endp=*/2,
3288                                          exp);
3289
3290       if (ret)
3291         return ret;
3292
3293       if (TREE_CODE (len) == INTEGER_CST)
3294         {
3295           rtx len_rtx = expand_normal (len);
3296
3297           if (CONST_INT_P (len_rtx))
3298             {
3299               ret = expand_builtin_strcpy_args (dst, src, target);
3300
3301               if (ret)
3302                 {
3303                   if (! target)
3304                     {
3305                       if (mode != VOIDmode)
3306                         target = gen_reg_rtx (mode);
3307                       else
3308                         target = gen_reg_rtx (GET_MODE (ret));
3309                     }
3310                   if (GET_MODE (target) != GET_MODE (ret))
3311                     ret = gen_lowpart (GET_MODE (target), ret);
3312
3313                   ret = plus_constant (GET_MODE (ret), ret, INTVAL (len_rtx));
3314                   ret = emit_move_insn (target, force_operand (ret, NULL_RTX));
3315                   gcc_assert (ret);
3316
3317                   return target;
3318                 }
3319             }
3320         }
3321
3322       return expand_movstr (dst, src, target, /*endp=*/2);
3323     }
3324 }
3325
3326 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3327    bytes from constant string DATA + OFFSET and return it as target
3328    constant.  */
3329
3330 rtx
3331 builtin_strncpy_read_str (void *data, HOST_WIDE_INT offset,
3332                           machine_mode mode)
3333 {
3334   const char *str = (const char *) data;
3335
3336   if ((unsigned HOST_WIDE_INT) offset > strlen (str))
3337     return const0_rtx;
3338
3339   return c_readstr (str + offset, mode);
3340 }
3341
3342 /* Expand expression EXP, which is a call to the strncpy builtin.  Return
3343    NULL_RTX if we failed the caller should emit a normal call.  */
3344
3345 static rtx
3346 expand_builtin_strncpy (tree exp, rtx target)
3347 {
3348   location_t loc = EXPR_LOCATION (exp);
3349
3350   if (validate_arglist (exp,
3351                         POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3352     {
3353       tree dest = CALL_EXPR_ARG (exp, 0);
3354       tree src = CALL_EXPR_ARG (exp, 1);
3355       tree len = CALL_EXPR_ARG (exp, 2);
3356       tree slen = c_strlen (src, 1);
3357
3358       /* We must be passed a constant len and src parameter.  */
3359       if (!tree_fits_uhwi_p (len) || !slen || !tree_fits_uhwi_p (slen))
3360         return NULL_RTX;
3361
3362       slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1));
3363
3364       /* We're required to pad with trailing zeros if the requested
3365          len is greater than strlen(s2)+1.  In that case try to
3366          use store_by_pieces, if it fails, punt.  */
3367       if (tree_int_cst_lt (slen, len))
3368         {
3369           unsigned int dest_align = get_pointer_alignment (dest);
3370           const char *p = c_getstr (src);
3371           rtx dest_mem;
3372
3373           if (!p || dest_align == 0 || !tree_fits_uhwi_p (len)
3374               || !can_store_by_pieces (tree_to_uhwi (len),
3375                                        builtin_strncpy_read_str,
3376                                        CONST_CAST (char *, p),
3377                                        dest_align, false))
3378             return NULL_RTX;
3379
3380           dest_mem = get_memory_rtx (dest, len);
3381           store_by_pieces (dest_mem, tree_to_uhwi (len),
3382                            builtin_strncpy_read_str,
3383                            CONST_CAST (char *, p), dest_align, false, 0);
3384           dest_mem = force_operand (XEXP (dest_mem, 0), target);
3385           dest_mem = convert_memory_address (ptr_mode, dest_mem);
3386           return dest_mem;
3387         }
3388     }
3389   return NULL_RTX;
3390 }
3391
3392 /* Callback routine for store_by_pieces.  Read GET_MODE_BITSIZE (MODE)
3393    bytes from constant string DATA + OFFSET and return it as target
3394    constant.  */
3395
3396 rtx
3397 builtin_memset_read_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3398                          machine_mode mode)
3399 {
3400   const char *c = (const char *) data;
3401   char *p = XALLOCAVEC (char, GET_MODE_SIZE (mode));
3402
3403   memset (p, *c, GET_MODE_SIZE (mode));
3404
3405   return c_readstr (p, mode);
3406 }
3407
3408 /* Callback routine for store_by_pieces.  Return the RTL of a register
3409    containing GET_MODE_SIZE (MODE) consecutive copies of the unsigned
3410    char value given in the RTL register data.  For example, if mode is
3411    4 bytes wide, return the RTL for 0x01010101*data.  */
3412
3413 static rtx
3414 builtin_memset_gen_str (void *data, HOST_WIDE_INT offset ATTRIBUTE_UNUSED,
3415                         machine_mode mode)
3416 {
3417   rtx target, coeff;
3418   size_t size;
3419   char *p;
3420
3421   size = GET_MODE_SIZE (mode);
3422   if (size == 1)
3423     return (rtx) data;
3424
3425   p = XALLOCAVEC (char, size);
3426   memset (p, 1, size);
3427   coeff = c_readstr (p, mode);
3428
3429   target = convert_to_mode (mode, (rtx) data, 1);
3430   target = expand_mult (mode, target, coeff, NULL_RTX, 1);
3431   return force_reg (mode, target);
3432 }
3433
3434 /* Expand expression EXP, which is a call to the memset builtin.  Return
3435    NULL_RTX if we failed the caller should emit a normal call, otherwise
3436    try to get the result in TARGET, if convenient (and in mode MODE if that's
3437    convenient).  */
3438
3439 static rtx
3440 expand_builtin_memset (tree exp, rtx target, machine_mode mode)
3441 {
3442   if (!validate_arglist (exp,
3443                          POINTER_TYPE, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3444     return NULL_RTX;
3445   else
3446     {
3447       tree dest = CALL_EXPR_ARG (exp, 0);
3448       tree val = CALL_EXPR_ARG (exp, 1);
3449       tree len = CALL_EXPR_ARG (exp, 2);
3450       return expand_builtin_memset_args (dest, val, len, target, mode, exp);
3451     }
3452 }
3453
3454 /* Expand expression EXP, which is an instrumented call to the memset builtin.
3455    Return NULL_RTX if we failed the caller should emit a normal call, otherwise
3456    try to get the result in TARGET, if convenient (and in mode MODE if that's
3457    convenient).  */
3458
3459 static rtx
3460 expand_builtin_memset_with_bounds (tree exp, rtx target, machine_mode mode)
3461 {
3462   if (!validate_arglist (exp,
3463                          POINTER_TYPE, POINTER_BOUNDS_TYPE,
3464                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
3465     return NULL_RTX;
3466   else
3467     {
3468       tree dest = CALL_EXPR_ARG (exp, 0);
3469       tree val = CALL_EXPR_ARG (exp, 2);
3470       tree len = CALL_EXPR_ARG (exp, 3);
3471       rtx res = expand_builtin_memset_args (dest, val, len, target, mode, exp);
3472
3473       /* Return src bounds with the result.  */
3474       if (res)
3475         {
3476           rtx bnd = force_reg (targetm.chkp_bound_mode (),
3477                                expand_normal (CALL_EXPR_ARG (exp, 1)));
3478           res = chkp_join_splitted_slot (res, bnd);
3479         }
3480       return res;
3481     }
3482 }
3483
3484 /* Helper function to do the actual work for expand_builtin_memset.  The
3485    arguments to the builtin_memset call DEST, VAL, and LEN are broken out
3486    so that this can also be called without constructing an actual CALL_EXPR.
3487    The other arguments and return value are the same as for
3488    expand_builtin_memset.  */
3489
3490 static rtx
3491 expand_builtin_memset_args (tree dest, tree val, tree len,
3492                             rtx target, machine_mode mode, tree orig_exp)
3493 {
3494   tree fndecl, fn;
3495   enum built_in_function fcode;
3496   machine_mode val_mode;
3497   char c;
3498   unsigned int dest_align;
3499   rtx dest_mem, dest_addr, len_rtx;
3500   HOST_WIDE_INT expected_size = -1;
3501   unsigned int expected_align = 0;
3502   unsigned HOST_WIDE_INT min_size;
3503   unsigned HOST_WIDE_INT max_size;
3504   unsigned HOST_WIDE_INT probable_max_size;
3505
3506   dest_align = get_pointer_alignment (dest);
3507
3508   /* If DEST is not a pointer type, don't do this operation in-line.  */
3509   if (dest_align == 0)
3510     return NULL_RTX;
3511
3512   if (currently_expanding_gimple_stmt)
3513     stringop_block_profile (currently_expanding_gimple_stmt,
3514                             &expected_align, &expected_size);
3515
3516   if (expected_align < dest_align)
3517     expected_align = dest_align;
3518
3519   /* If the LEN parameter is zero, return DEST.  */
3520   if (integer_zerop (len))
3521     {
3522       /* Evaluate and ignore VAL in case it has side-effects.  */
3523       expand_expr (val, const0_rtx, VOIDmode, EXPAND_NORMAL);
3524       return expand_expr (dest, target, mode, EXPAND_NORMAL);
3525     }
3526
3527   /* Stabilize the arguments in case we fail.  */
3528   dest = builtin_save_expr (dest);
3529   val = builtin_save_expr (val);
3530   len = builtin_save_expr (len);
3531
3532   len_rtx = expand_normal (len);
3533   determine_block_size (len, len_rtx, &min_size, &max_size,
3534                         &probable_max_size);
3535   dest_mem = get_memory_rtx (dest, len);
3536   val_mode = TYPE_MODE (unsigned_char_type_node);
3537
3538   if (TREE_CODE (val) != INTEGER_CST)
3539     {
3540       rtx val_rtx;
3541
3542       val_rtx = expand_normal (val);
3543       val_rtx = convert_to_mode (val_mode, val_rtx, 0);
3544
3545       /* Assume that we can memset by pieces if we can store
3546        * the coefficients by pieces (in the required modes).
3547        * We can't pass builtin_memset_gen_str as that emits RTL.  */
3548       c = 1;
3549       if (tree_fits_uhwi_p (len)
3550           && can_store_by_pieces (tree_to_uhwi (len),
3551                                   builtin_memset_read_str, &c, dest_align,
3552                                   true))
3553         {
3554           val_rtx = force_reg (val_mode, val_rtx);
3555           store_by_pieces (dest_mem, tree_to_uhwi (len),
3556                            builtin_memset_gen_str, val_rtx, dest_align,
3557                            true, 0);
3558         }
3559       else if (!set_storage_via_setmem (dest_mem, len_rtx, val_rtx,
3560                                         dest_align, expected_align,
3561                                         expected_size, min_size, max_size,
3562                                         probable_max_size))
3563         goto do_libcall;
3564
3565       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3566       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3567       return dest_mem;
3568     }
3569
3570   if (target_char_cast (val, &c))
3571     goto do_libcall;
3572
3573   if (c)
3574     {
3575       if (tree_fits_uhwi_p (len)
3576           && can_store_by_pieces (tree_to_uhwi (len),
3577                                   builtin_memset_read_str, &c, dest_align,
3578                                   true))
3579         store_by_pieces (dest_mem, tree_to_uhwi (len),
3580                          builtin_memset_read_str, &c, dest_align, true, 0);
3581       else if (!set_storage_via_setmem (dest_mem, len_rtx,
3582                                         gen_int_mode (c, val_mode),
3583                                         dest_align, expected_align,
3584                                         expected_size, min_size, max_size,
3585                                         probable_max_size))
3586         goto do_libcall;
3587
3588       dest_mem = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3589       dest_mem = convert_memory_address (ptr_mode, dest_mem);
3590       return dest_mem;
3591     }
3592
3593   set_mem_align (dest_mem, dest_align);
3594   dest_addr = clear_storage_hints (dest_mem, len_rtx,
3595                                    CALL_EXPR_TAILCALL (orig_exp)
3596                                    ? BLOCK_OP_TAILCALL : BLOCK_OP_NORMAL,
3597                                    expected_align, expected_size,
3598                                    min_size, max_size,
3599                                    probable_max_size);
3600
3601   if (dest_addr == 0)
3602     {
3603       dest_addr = force_operand (XEXP (dest_mem, 0), NULL_RTX);
3604       dest_addr = convert_memory_address (ptr_mode, dest_addr);
3605     }
3606
3607   return dest_addr;
3608
3609  do_libcall:
3610   fndecl = get_callee_fndecl (orig_exp);
3611   fcode = DECL_FUNCTION_CODE (fndecl);
3612   if (fcode == BUILT_IN_MEMSET
3613       || fcode == BUILT_IN_CHKP_MEMSET_NOBND_NOCHK_CHKP)
3614     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 3,
3615                                 dest, val, len);
3616   else if (fcode == BUILT_IN_BZERO)
3617     fn = build_call_nofold_loc (EXPR_LOCATION (orig_exp), fndecl, 2,
3618                                 dest, len);
3619   else
3620     gcc_unreachable ();
3621   gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3622   CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (orig_exp);
3623   return expand_call (fn, target, target == const0_rtx);
3624 }
3625
3626 /* Expand expression EXP, which is a call to the bzero builtin.  Return
3627    NULL_RTX if we failed the caller should emit a normal call.  */
3628
3629 static rtx
3630 expand_builtin_bzero (tree exp)
3631 {
3632   tree dest, size;
3633   location_t loc = EXPR_LOCATION (exp);
3634
3635   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3636     return NULL_RTX;
3637
3638   dest = CALL_EXPR_ARG (exp, 0);
3639   size = CALL_EXPR_ARG (exp, 1);
3640
3641   /* New argument list transforming bzero(ptr x, int y) to
3642      memset(ptr x, int 0, size_t y).   This is done this way
3643      so that if it isn't expanded inline, we fallback to
3644      calling bzero instead of memset.  */
3645
3646   return expand_builtin_memset_args (dest, integer_zero_node,
3647                                      fold_convert_loc (loc,
3648                                                        size_type_node, size),
3649                                      const0_rtx, VOIDmode, exp);
3650 }
3651
3652 /* Try to expand cmpstr operation ICODE with the given operands.
3653    Return the result rtx on success, otherwise return null.  */
3654
3655 static rtx
3656 expand_cmpstr (insn_code icode, rtx target, rtx arg1_rtx, rtx arg2_rtx,
3657                HOST_WIDE_INT align)
3658 {
3659   machine_mode insn_mode = insn_data[icode].operand[0].mode;
3660
3661   if (target && (!REG_P (target) || HARD_REGISTER_P (target)))
3662     target = NULL_RTX;
3663
3664   struct expand_operand ops[4];
3665   create_output_operand (&ops[0], target, insn_mode);
3666   create_fixed_operand (&ops[1], arg1_rtx);
3667   create_fixed_operand (&ops[2], arg2_rtx);
3668   create_integer_operand (&ops[3], align);
3669   if (maybe_expand_insn (icode, 4, ops))
3670     return ops[0].value;
3671   return NULL_RTX;
3672 }
3673
3674 /* Try to expand cmpstrn or cmpmem operation ICODE with the given operands.
3675    ARG3_TYPE is the type of ARG3_RTX.  Return the result rtx on success,
3676    otherwise return null.  */
3677
3678 static rtx
3679 expand_cmpstrn_or_cmpmem (insn_code icode, rtx target, rtx arg1_rtx,
3680                           rtx arg2_rtx, tree arg3_type, rtx arg3_rtx,
3681                           HOST_WIDE_INT align)
3682 {
3683   machine_mode insn_mode = insn_data[icode].operand[0].mode;
3684
3685   if (target && (!REG_P (target) || HARD_REGISTER_P (target)))
3686     target = NULL_RTX;
3687
3688   struct expand_operand ops[5];
3689   create_output_operand (&ops[0], target, insn_mode);
3690   create_fixed_operand (&ops[1], arg1_rtx);
3691   create_fixed_operand (&ops[2], arg2_rtx);
3692   create_convert_operand_from (&ops[3], arg3_rtx, TYPE_MODE (arg3_type),
3693                                TYPE_UNSIGNED (arg3_type));
3694   create_integer_operand (&ops[4], align);
3695   if (maybe_expand_insn (icode, 5, ops))
3696     return ops[0].value;
3697   return NULL_RTX;
3698 }
3699
3700 /* Expand expression EXP, which is a call to the memcmp built-in function.
3701    Return NULL_RTX if we failed and the caller should emit a normal call,
3702    otherwise try to get the result in TARGET, if convenient.  */
3703
3704 static rtx
3705 expand_builtin_memcmp (tree exp, rtx target)
3706 {
3707   if (!validate_arglist (exp,
3708                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3709     return NULL_RTX;
3710
3711   /* Note: The cmpstrnsi pattern, if it exists, is not suitable for
3712      implementing memcmp because it will stop if it encounters two
3713      zero bytes.  */
3714   insn_code icode = direct_optab_handler (cmpmem_optab, SImode);
3715   if (icode == CODE_FOR_nothing)
3716     return NULL_RTX;
3717
3718   tree arg1 = CALL_EXPR_ARG (exp, 0);
3719   tree arg2 = CALL_EXPR_ARG (exp, 1);
3720   tree len = CALL_EXPR_ARG (exp, 2);
3721
3722   unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3723   unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3724
3725   /* If we don't have POINTER_TYPE, call the function.  */
3726   if (arg1_align == 0 || arg2_align == 0)
3727     return NULL_RTX;
3728
3729   machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
3730   location_t loc = EXPR_LOCATION (exp);
3731   rtx arg1_rtx = get_memory_rtx (arg1, len);
3732   rtx arg2_rtx = get_memory_rtx (arg2, len);
3733   rtx arg3_rtx = expand_normal (fold_convert_loc (loc, sizetype, len));
3734
3735   /* Set MEM_SIZE as appropriate.  */
3736   if (CONST_INT_P (arg3_rtx))
3737     {
3738       set_mem_size (arg1_rtx, INTVAL (arg3_rtx));
3739       set_mem_size (arg2_rtx, INTVAL (arg3_rtx));
3740     }
3741
3742   rtx result = expand_cmpstrn_or_cmpmem (icode, target, arg1_rtx, arg2_rtx,
3743                                          TREE_TYPE (len), arg3_rtx,
3744                                          MIN (arg1_align, arg2_align));
3745   if (result)
3746     {
3747       /* Return the value in the proper mode for this function.  */
3748       if (GET_MODE (result) == mode)
3749         return result;
3750
3751       if (target != 0)
3752         {
3753           convert_move (target, result, 0);
3754           return target;
3755         }
3756
3757       return convert_to_mode (mode, result, 0);
3758     }
3759
3760   result = target;
3761   if (! (result != 0
3762          && REG_P (result) && GET_MODE (result) == mode
3763          && REGNO (result) >= FIRST_PSEUDO_REGISTER))
3764     result = gen_reg_rtx (mode);
3765
3766   emit_library_call_value (memcmp_libfunc, result, LCT_PURE,
3767                            TYPE_MODE (integer_type_node), 3,
3768                            XEXP (arg1_rtx, 0), Pmode,
3769                            XEXP (arg2_rtx, 0), Pmode,
3770                            convert_to_mode (TYPE_MODE (sizetype), arg3_rtx,
3771                                             TYPE_UNSIGNED (sizetype)),
3772                            TYPE_MODE (sizetype));
3773   return result;
3774 }
3775
3776 /* Expand expression EXP, which is a call to the strcmp builtin.  Return NULL_RTX
3777    if we failed the caller should emit a normal call, otherwise try to get
3778    the result in TARGET, if convenient.  */
3779
3780 static rtx
3781 expand_builtin_strcmp (tree exp, ATTRIBUTE_UNUSED rtx target)
3782 {
3783   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
3784     return NULL_RTX;
3785
3786   insn_code cmpstr_icode = direct_optab_handler (cmpstr_optab, SImode);
3787   insn_code cmpstrn_icode = direct_optab_handler (cmpstrn_optab, SImode);
3788   if (cmpstr_icode != CODE_FOR_nothing || cmpstrn_icode != CODE_FOR_nothing)
3789     {
3790       rtx arg1_rtx, arg2_rtx;
3791       tree fndecl, fn;
3792       tree arg1 = CALL_EXPR_ARG (exp, 0);
3793       tree arg2 = CALL_EXPR_ARG (exp, 1);
3794       rtx result = NULL_RTX;
3795
3796       unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3797       unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3798
3799       /* If we don't have POINTER_TYPE, call the function.  */
3800       if (arg1_align == 0 || arg2_align == 0)
3801         return NULL_RTX;
3802
3803       /* Stabilize the arguments in case gen_cmpstr(n)si fail.  */
3804       arg1 = builtin_save_expr (arg1);
3805       arg2 = builtin_save_expr (arg2);
3806
3807       arg1_rtx = get_memory_rtx (arg1, NULL);
3808       arg2_rtx = get_memory_rtx (arg2, NULL);
3809
3810       /* Try to call cmpstrsi.  */
3811       if (cmpstr_icode != CODE_FOR_nothing)
3812         result = expand_cmpstr (cmpstr_icode, target, arg1_rtx, arg2_rtx,
3813                                 MIN (arg1_align, arg2_align));
3814
3815       /* Try to determine at least one length and call cmpstrnsi.  */
3816       if (!result && cmpstrn_icode != CODE_FOR_nothing)
3817         {
3818           tree len;
3819           rtx arg3_rtx;
3820
3821           tree len1 = c_strlen (arg1, 1);
3822           tree len2 = c_strlen (arg2, 1);
3823
3824           if (len1)
3825             len1 = size_binop (PLUS_EXPR, ssize_int (1), len1);
3826           if (len2)
3827             len2 = size_binop (PLUS_EXPR, ssize_int (1), len2);
3828
3829           /* If we don't have a constant length for the first, use the length
3830              of the second, if we know it.  We don't require a constant for
3831              this case; some cost analysis could be done if both are available
3832              but neither is constant.  For now, assume they're equally cheap,
3833              unless one has side effects.  If both strings have constant lengths,
3834              use the smaller.  */
3835
3836           if (!len1)
3837             len = len2;
3838           else if (!len2)
3839             len = len1;
3840           else if (TREE_SIDE_EFFECTS (len1))
3841             len = len2;
3842           else if (TREE_SIDE_EFFECTS (len2))
3843             len = len1;
3844           else if (TREE_CODE (len1) != INTEGER_CST)
3845             len = len2;
3846           else if (TREE_CODE (len2) != INTEGER_CST)
3847             len = len1;
3848           else if (tree_int_cst_lt (len1, len2))
3849             len = len1;
3850           else
3851             len = len2;
3852
3853           /* If both arguments have side effects, we cannot optimize.  */
3854           if (len && !TREE_SIDE_EFFECTS (len))
3855             {
3856               arg3_rtx = expand_normal (len);
3857               result = expand_cmpstrn_or_cmpmem
3858                 (cmpstrn_icode, target, arg1_rtx, arg2_rtx, TREE_TYPE (len),
3859                  arg3_rtx, MIN (arg1_align, arg2_align));
3860             }
3861         }
3862
3863       if (result)
3864         {
3865           /* Return the value in the proper mode for this function.  */
3866           machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
3867           if (GET_MODE (result) == mode)
3868             return result;
3869           if (target == 0)
3870             return convert_to_mode (mode, result, 0);
3871           convert_move (target, result, 0);
3872           return target;
3873         }
3874
3875       /* Expand the library call ourselves using a stabilized argument
3876          list to avoid re-evaluating the function's arguments twice.  */
3877       fndecl = get_callee_fndecl (exp);
3878       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 2, arg1, arg2);
3879       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3880       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
3881       return expand_call (fn, target, target == const0_rtx);
3882     }
3883   return NULL_RTX;
3884 }
3885
3886 /* Expand expression EXP, which is a call to the strncmp builtin. Return
3887    NULL_RTX if we failed the caller should emit a normal call, otherwise try to get
3888    the result in TARGET, if convenient.  */
3889
3890 static rtx
3891 expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target,
3892                         ATTRIBUTE_UNUSED machine_mode mode)
3893 {
3894   location_t loc ATTRIBUTE_UNUSED = EXPR_LOCATION (exp);
3895
3896   if (!validate_arglist (exp,
3897                          POINTER_TYPE, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
3898     return NULL_RTX;
3899
3900   /* If c_strlen can determine an expression for one of the string
3901      lengths, and it doesn't have side effects, then emit cmpstrnsi
3902      using length MIN(strlen(string)+1, arg3).  */
3903   insn_code cmpstrn_icode = direct_optab_handler (cmpstrn_optab, SImode);
3904   if (cmpstrn_icode != CODE_FOR_nothing)
3905   {
3906     tree len, len1, len2;
3907     rtx arg1_rtx, arg2_rtx, arg3_rtx;
3908     rtx result;
3909     tree fndecl, fn;
3910     tree arg1 = CALL_EXPR_ARG (exp, 0);
3911     tree arg2 = CALL_EXPR_ARG (exp, 1);
3912     tree arg3 = CALL_EXPR_ARG (exp, 2);
3913
3914     unsigned int arg1_align = get_pointer_alignment (arg1) / BITS_PER_UNIT;
3915     unsigned int arg2_align = get_pointer_alignment (arg2) / BITS_PER_UNIT;
3916
3917     len1 = c_strlen (arg1, 1);
3918     len2 = c_strlen (arg2, 1);
3919
3920     if (len1)
3921       len1 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len1);
3922     if (len2)
3923       len2 = size_binop_loc (loc, PLUS_EXPR, ssize_int (1), len2);
3924
3925     /* If we don't have a constant length for the first, use the length
3926        of the second, if we know it.  We don't require a constant for
3927        this case; some cost analysis could be done if both are available
3928        but neither is constant.  For now, assume they're equally cheap,
3929        unless one has side effects.  If both strings have constant lengths,
3930        use the smaller.  */
3931
3932     if (!len1)
3933       len = len2;
3934     else if (!len2)
3935       len = len1;
3936     else if (TREE_SIDE_EFFECTS (len1))
3937       len = len2;
3938     else if (TREE_SIDE_EFFECTS (len2))
3939       len = len1;
3940     else if (TREE_CODE (len1) != INTEGER_CST)
3941       len = len2;
3942     else if (TREE_CODE (len2) != INTEGER_CST)
3943       len = len1;
3944     else if (tree_int_cst_lt (len1, len2))
3945       len = len1;
3946     else
3947       len = len2;
3948
3949     /* If both arguments have side effects, we cannot optimize.  */
3950     if (!len || TREE_SIDE_EFFECTS (len))
3951       return NULL_RTX;
3952
3953     /* The actual new length parameter is MIN(len,arg3).  */
3954     len = fold_build2_loc (loc, MIN_EXPR, TREE_TYPE (len), len,
3955                        fold_convert_loc (loc, TREE_TYPE (len), arg3));
3956
3957     /* If we don't have POINTER_TYPE, call the function.  */
3958     if (arg1_align == 0 || arg2_align == 0)
3959       return NULL_RTX;
3960
3961     /* Stabilize the arguments in case gen_cmpstrnsi fails.  */
3962     arg1 = builtin_save_expr (arg1);
3963     arg2 = builtin_save_expr (arg2);
3964     len = builtin_save_expr (len);
3965
3966     arg1_rtx = get_memory_rtx (arg1, len);
3967     arg2_rtx = get_memory_rtx (arg2, len);
3968     arg3_rtx = expand_normal (len);
3969     result = expand_cmpstrn_or_cmpmem (cmpstrn_icode, target, arg1_rtx,
3970                                        arg2_rtx, TREE_TYPE (len), arg3_rtx,
3971                                        MIN (arg1_align, arg2_align));
3972     if (result)
3973       {
3974         /* Return the value in the proper mode for this function.  */
3975         mode = TYPE_MODE (TREE_TYPE (exp));
3976         if (GET_MODE (result) == mode)
3977           return result;
3978         if (target == 0)
3979           return convert_to_mode (mode, result, 0);
3980         convert_move (target, result, 0);
3981         return target;
3982       }
3983
3984     /* Expand the library call ourselves using a stabilized argument
3985        list to avoid re-evaluating the function's arguments twice.  */
3986     fndecl = get_callee_fndecl (exp);
3987     fn = build_call_nofold_loc (EXPR_LOCATION (exp), fndecl, 3,
3988                                 arg1, arg2, len);
3989     gcc_assert (TREE_CODE (fn) == CALL_EXPR);
3990     CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
3991     return expand_call (fn, target, target == const0_rtx);
3992   }
3993   return NULL_RTX;
3994 }
3995
3996 /* Expand a call to __builtin_saveregs, generating the result in TARGET,
3997    if that's convenient.  */
3998
3999 rtx
4000 expand_builtin_saveregs (void)
4001 {
4002   rtx val;
4003   rtx_insn *seq;
4004
4005   /* Don't do __builtin_saveregs more than once in a function.
4006      Save the result of the first call and reuse it.  */
4007   if (saveregs_value != 0)
4008     return saveregs_value;
4009
4010   /* When this function is called, it means that registers must be
4011      saved on entry to this function.  So we migrate the call to the
4012      first insn of this function.  */
4013
4014   start_sequence ();
4015
4016   /* Do whatever the machine needs done in this case.  */
4017   val = targetm.calls.expand_builtin_saveregs ();
4018
4019   seq = get_insns ();
4020   end_sequence ();
4021
4022   saveregs_value = val;
4023
4024   /* Put the insns after the NOTE that starts the function.  If this
4025      is inside a start_sequence, make the outer-level insn chain current, so
4026      the code is placed at the start of the function.  */
4027   push_topmost_sequence ();
4028   emit_insn_after (seq, entry_of_function ());
4029   pop_topmost_sequence ();
4030
4031   return val;
4032 }
4033
4034 /* Expand a call to __builtin_next_arg.  */
4035
4036 static rtx
4037 expand_builtin_next_arg (void)
4038 {
4039   /* Checking arguments is already done in fold_builtin_next_arg
4040      that must be called before this function.  */
4041   return expand_binop (ptr_mode, add_optab,
4042                        crtl->args.internal_arg_pointer,
4043                        crtl->args.arg_offset_rtx,
4044                        NULL_RTX, 0, OPTAB_LIB_WIDEN);
4045 }
4046
4047 /* Make it easier for the backends by protecting the valist argument
4048    from multiple evaluations.  */
4049
4050 static tree
4051 stabilize_va_list_loc (location_t loc, tree valist, int needs_lvalue)
4052 {
4053   tree vatype = targetm.canonical_va_list_type (TREE_TYPE (valist));
4054
4055   /* The current way of determining the type of valist is completely
4056      bogus.  We should have the information on the va builtin instead.  */
4057   if (!vatype)
4058     vatype = targetm.fn_abi_va_list (cfun->decl);
4059
4060   if (TREE_CODE (vatype) == ARRAY_TYPE)
4061     {
4062       if (TREE_SIDE_EFFECTS (valist))
4063         valist = save_expr (valist);
4064
4065       /* For this case, the backends will be expecting a pointer to
4066          vatype, but it's possible we've actually been given an array
4067          (an actual TARGET_CANONICAL_VA_LIST_TYPE (valist)).
4068          So fix it.  */
4069       if (TREE_CODE (TREE_TYPE (valist)) == ARRAY_TYPE)
4070         {
4071           tree p1 = build_pointer_type (TREE_TYPE (vatype));
4072           valist = build_fold_addr_expr_with_type_loc (loc, valist, p1);
4073         }
4074     }
4075   else
4076     {
4077       tree pt = build_pointer_type (vatype);
4078
4079       if (! needs_lvalue)
4080         {
4081           if (! TREE_SIDE_EFFECTS (valist))
4082             return valist;
4083
4084           valist = fold_build1_loc (loc, ADDR_EXPR, pt, valist);
4085           TREE_SIDE_EFFECTS (valist) = 1;
4086         }
4087
4088       if (TREE_SIDE_EFFECTS (valist))
4089         valist = save_expr (valist);
4090       valist = fold_build2_loc (loc, MEM_REF,
4091                                 vatype, valist, build_int_cst (pt, 0));
4092     }
4093
4094   return valist;
4095 }
4096
4097 /* The "standard" definition of va_list is void*.  */
4098
4099 tree
4100 std_build_builtin_va_list (void)
4101 {
4102   return ptr_type_node;
4103 }
4104
4105 /* The "standard" abi va_list is va_list_type_node.  */
4106
4107 tree
4108 std_fn_abi_va_list (tree fndecl ATTRIBUTE_UNUSED)
4109 {
4110   return va_list_type_node;
4111 }
4112
4113 /* The "standard" type of va_list is va_list_type_node.  */
4114
4115 tree
4116 std_canonical_va_list_type (tree type)
4117 {
4118   tree wtype, htype;
4119
4120   if (INDIRECT_REF_P (type))
4121     type = TREE_TYPE (type);
4122   else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE (type)))
4123     type = TREE_TYPE (type);
4124   wtype = va_list_type_node;
4125   htype = type;
4126   /* Treat structure va_list types.  */
4127   if (TREE_CODE (wtype) == RECORD_TYPE && POINTER_TYPE_P (htype))
4128     htype = TREE_TYPE (htype);
4129   else if (TREE_CODE (wtype) == ARRAY_TYPE)
4130     {
4131       /* If va_list is an array type, the argument may have decayed
4132          to a pointer type, e.g. by being passed to another function.
4133          In that case, unwrap both types so that we can compare the
4134          underlying records.  */
4135       if (TREE_CODE (htype) == ARRAY_TYPE
4136           || POINTER_TYPE_P (htype))
4137         {
4138           wtype = TREE_TYPE (wtype);
4139           htype = TREE_TYPE (htype);
4140         }
4141     }
4142   if (TYPE_MAIN_VARIANT (wtype) == TYPE_MAIN_VARIANT (htype))
4143     return va_list_type_node;
4144
4145   return NULL_TREE;
4146 }
4147
4148 /* The "standard" implementation of va_start: just assign `nextarg' to
4149    the variable.  */
4150
4151 void
4152 std_expand_builtin_va_start (tree valist, rtx nextarg)
4153 {
4154   rtx va_r = expand_expr (valist, NULL_RTX, VOIDmode, EXPAND_WRITE);
4155   convert_move (va_r, nextarg, 0);
4156
4157   /* We do not have any valid bounds for the pointer, so
4158      just store zero bounds for it.  */
4159   if (chkp_function_instrumented_p (current_function_decl))
4160     chkp_expand_bounds_reset_for_mem (valist,
4161                                       make_tree (TREE_TYPE (valist),
4162                                                  nextarg));
4163 }
4164
4165 /* Expand EXP, a call to __builtin_va_start.  */
4166
4167 static rtx
4168 expand_builtin_va_start (tree exp)
4169 {
4170   rtx nextarg;
4171   tree valist;
4172   location_t loc = EXPR_LOCATION (exp);
4173
4174   if (call_expr_nargs (exp) < 2)
4175     {
4176       error_at (loc, "too few arguments to function %<va_start%>");
4177       return const0_rtx;
4178     }
4179
4180   if (fold_builtin_next_arg (exp, true))
4181     return const0_rtx;
4182
4183   nextarg = expand_builtin_next_arg ();
4184   valist = stabilize_va_list_loc (loc, CALL_EXPR_ARG (exp, 0), 1);
4185
4186   if (targetm.expand_builtin_va_start)
4187     targetm.expand_builtin_va_start (valist, nextarg);
4188   else
4189     std_expand_builtin_va_start (valist, nextarg);
4190
4191   return const0_rtx;
4192 }
4193
4194 /* Expand EXP, a call to __builtin_va_end.  */
4195
4196 static rtx
4197 expand_builtin_va_end (tree exp)
4198 {
4199   tree valist = CALL_EXPR_ARG (exp, 0);
4200
4201   /* Evaluate for side effects, if needed.  I hate macros that don't
4202      do that.  */
4203   if (TREE_SIDE_EFFECTS (valist))
4204     expand_expr (valist, const0_rtx, VOIDmode, EXPAND_NORMAL);
4205
4206   return const0_rtx;
4207 }
4208
4209 /* Expand EXP, a call to __builtin_va_copy.  We do this as a
4210    builtin rather than just as an assignment in stdarg.h because of the
4211    nastiness of array-type va_list types.  */
4212
4213 static rtx
4214 expand_builtin_va_copy (tree exp)
4215 {
4216   tree dst, src, t;
4217   location_t loc = EXPR_LOCATION (exp);
4218
4219   dst = CALL_EXPR_ARG (exp, 0);
4220   src = CALL_EXPR_ARG (exp, 1);
4221
4222   dst = stabilize_va_list_loc (loc, dst, 1);
4223   src = stabilize_va_list_loc (loc, src, 0);
4224
4225   gcc_assert (cfun != NULL && cfun->decl != NULL_TREE);
4226
4227   if (TREE_CODE (targetm.fn_abi_va_list (cfun->decl)) != ARRAY_TYPE)
4228     {
4229       t = build2 (MODIFY_EXPR, targetm.fn_abi_va_list (cfun->decl), dst, src);
4230       TREE_SIDE_EFFECTS (t) = 1;
4231       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4232     }
4233   else
4234     {
4235       rtx dstb, srcb, size;
4236
4237       /* Evaluate to pointers.  */
4238       dstb = expand_expr (dst, NULL_RTX, Pmode, EXPAND_NORMAL);
4239       srcb = expand_expr (src, NULL_RTX, Pmode, EXPAND_NORMAL);
4240       size = expand_expr (TYPE_SIZE_UNIT (targetm.fn_abi_va_list (cfun->decl)),
4241                   NULL_RTX, VOIDmode, EXPAND_NORMAL);
4242
4243       dstb = convert_memory_address (Pmode, dstb);
4244       srcb = convert_memory_address (Pmode, srcb);
4245
4246       /* "Dereference" to BLKmode memories.  */
4247       dstb = gen_rtx_MEM (BLKmode, dstb);
4248       set_mem_alias_set (dstb, get_alias_set (TREE_TYPE (TREE_TYPE (dst))));
4249       set_mem_align (dstb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4250       srcb = gen_rtx_MEM (BLKmode, srcb);
4251       set_mem_alias_set (srcb, get_alias_set (TREE_TYPE (TREE_TYPE (src))));
4252       set_mem_align (srcb, TYPE_ALIGN (targetm.fn_abi_va_list (cfun->decl)));
4253
4254       /* Copy.  */
4255       emit_block_move (dstb, srcb, size, BLOCK_OP_NORMAL);
4256     }
4257
4258   return const0_rtx;
4259 }
4260
4261 /* Expand a call to one of the builtin functions __builtin_frame_address or
4262    __builtin_return_address.  */
4263
4264 static rtx
4265 expand_builtin_frame_address (tree fndecl, tree exp)
4266 {
4267   /* The argument must be a nonnegative integer constant.
4268      It counts the number of frames to scan up the stack.
4269      The value is either the frame pointer value or the return
4270      address saved in that frame.  */
4271   if (call_expr_nargs (exp) == 0)
4272     /* Warning about missing arg was already issued.  */
4273     return const0_rtx;
4274   else if (! tree_fits_uhwi_p (CALL_EXPR_ARG (exp, 0)))
4275     {
4276       error ("invalid argument to %qD", fndecl);
4277       return const0_rtx;
4278     }
4279   else
4280     {
4281       /* Number of frames to scan up the stack.  */
4282       unsigned HOST_WIDE_INT count = tree_to_uhwi (CALL_EXPR_ARG (exp, 0));
4283
4284       rtx tem = expand_builtin_return_addr (DECL_FUNCTION_CODE (fndecl), count);
4285
4286       /* Some ports cannot access arbitrary stack frames.  */
4287       if (tem == NULL)
4288         {
4289           warning (0, "unsupported argument to %qD", fndecl);
4290           return const0_rtx;
4291         }
4292
4293       if (count)
4294         {
4295           /* Warn since no effort is made to ensure that any frame
4296              beyond the current one exists or can be safely reached.  */
4297           warning (OPT_Wframe_address, "calling %qD with "
4298                    "a nonzero argument is unsafe", fndecl);
4299         }
4300
4301       /* For __builtin_frame_address, return what we've got.  */
4302       if (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FRAME_ADDRESS)
4303         return tem;
4304
4305       if (!REG_P (tem)
4306           && ! CONSTANT_P (tem))
4307         tem = copy_addr_to_reg (tem);
4308       return tem;
4309     }
4310 }
4311
4312 /* Expand EXP, a call to the alloca builtin.  Return NULL_RTX if we
4313    failed and the caller should emit a normal call.  CANNOT_ACCUMULATE
4314    is the same as for allocate_dynamic_stack_space.  */
4315
4316 static rtx
4317 expand_builtin_alloca (tree exp, bool cannot_accumulate)
4318 {
4319   rtx op0;
4320   rtx result;
4321   bool valid_arglist;
4322   unsigned int align;
4323   bool alloca_with_align = (DECL_FUNCTION_CODE (get_callee_fndecl (exp))
4324                             == BUILT_IN_ALLOCA_WITH_ALIGN);
4325
4326   valid_arglist
4327     = (alloca_with_align
4328        ? validate_arglist (exp, INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE)
4329        : validate_arglist (exp, INTEGER_TYPE, VOID_TYPE));
4330
4331   if (!valid_arglist)
4332     return NULL_RTX;
4333
4334   /* Compute the argument.  */
4335   op0 = expand_normal (CALL_EXPR_ARG (exp, 0));
4336
4337   /* Compute the alignment.  */
4338   align = (alloca_with_align
4339            ? TREE_INT_CST_LOW (CALL_EXPR_ARG (exp, 1))
4340            : BIGGEST_ALIGNMENT);
4341
4342   /* Allocate the desired space.  */
4343   result = allocate_dynamic_stack_space (op0, 0, align, cannot_accumulate);
4344   result = convert_memory_address (ptr_mode, result);
4345
4346   return result;
4347 }
4348
4349 /* Expand a call to bswap builtin in EXP.
4350    Return NULL_RTX if a normal call should be emitted rather than expanding the
4351    function in-line.  If convenient, the result should be placed in TARGET.
4352    SUBTARGET may be used as the target for computing one of EXP's operands.  */
4353
4354 static rtx
4355 expand_builtin_bswap (machine_mode target_mode, tree exp, rtx target,
4356                       rtx subtarget)
4357 {
4358   tree arg;
4359   rtx op0;
4360
4361   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4362     return NULL_RTX;
4363
4364   arg = CALL_EXPR_ARG (exp, 0);
4365   op0 = expand_expr (arg,
4366                      subtarget && GET_MODE (subtarget) == target_mode
4367                      ? subtarget : NULL_RTX,
4368                      target_mode, EXPAND_NORMAL);
4369   if (GET_MODE (op0) != target_mode)
4370     op0 = convert_to_mode (target_mode, op0, 1);
4371
4372   target = expand_unop (target_mode, bswap_optab, op0, target, 1);
4373
4374   gcc_assert (target);
4375
4376   return convert_to_mode (target_mode, target, 1);
4377 }
4378
4379 /* Expand a call to a unary builtin in EXP.
4380    Return NULL_RTX if a normal call should be emitted rather than expanding the
4381    function in-line.  If convenient, the result should be placed in TARGET.
4382    SUBTARGET may be used as the target for computing one of EXP's operands.  */
4383
4384 static rtx
4385 expand_builtin_unop (machine_mode target_mode, tree exp, rtx target,
4386                      rtx subtarget, optab op_optab)
4387 {
4388   rtx op0;
4389
4390   if (!validate_arglist (exp, INTEGER_TYPE, VOID_TYPE))
4391     return NULL_RTX;
4392
4393   /* Compute the argument.  */
4394   op0 = expand_expr (CALL_EXPR_ARG (exp, 0),
4395                      (subtarget
4396                       && (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0)))
4397                           == GET_MODE (subtarget))) ? subtarget : NULL_RTX,
4398                      VOIDmode, EXPAND_NORMAL);
4399   /* Compute op, into TARGET if possible.
4400      Set TARGET to wherever the result comes back.  */
4401   target = expand_unop (TYPE_MODE (TREE_TYPE (CALL_EXPR_ARG (exp, 0))),
4402                         op_optab, op0, target, op_optab != clrsb_optab);
4403   gcc_assert (target);
4404
4405   return convert_to_mode (target_mode, target, 0);
4406 }
4407
4408 /* Expand a call to __builtin_expect.  We just return our argument
4409    as the builtin_expect semantic should've been already executed by
4410    tree branch prediction pass. */
4411
4412 static rtx
4413 expand_builtin_expect (tree exp, rtx target)
4414 {
4415   tree arg;
4416
4417   if (call_expr_nargs (exp) < 2)
4418     return const0_rtx;
4419   arg = CALL_EXPR_ARG (exp, 0);
4420
4421   target = expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4422   /* When guessing was done, the hints should be already stripped away.  */
4423   gcc_assert (!flag_guess_branch_prob
4424               || optimize == 0 || seen_error ());
4425   return target;
4426 }
4427
4428 /* Expand a call to __builtin_assume_aligned.  We just return our first
4429    argument as the builtin_assume_aligned semantic should've been already
4430    executed by CCP.  */
4431
4432 static rtx
4433 expand_builtin_assume_aligned (tree exp, rtx target)
4434 {
4435   if (call_expr_nargs (exp) < 2)
4436     return const0_rtx;
4437   target = expand_expr (CALL_EXPR_ARG (exp, 0), target, VOIDmode,
4438                         EXPAND_NORMAL);
4439   gcc_assert (!TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 1))
4440               && (call_expr_nargs (exp) < 3
4441                   || !TREE_SIDE_EFFECTS (CALL_EXPR_ARG (exp, 2))));
4442   return target;
4443 }
4444
4445 void
4446 expand_builtin_trap (void)
4447 {
4448   if (targetm.have_trap ())
4449     {
4450       rtx_insn *insn = emit_insn (targetm.gen_trap ());
4451       /* For trap insns when not accumulating outgoing args force
4452          REG_ARGS_SIZE note to prevent crossjumping of calls with
4453          different args sizes.  */
4454       if (!ACCUMULATE_OUTGOING_ARGS)
4455         add_reg_note (insn, REG_ARGS_SIZE, GEN_INT (stack_pointer_delta));
4456     }
4457   else
4458     emit_library_call (abort_libfunc, LCT_NORETURN, VOIDmode, 0);
4459   emit_barrier ();
4460 }
4461
4462 /* Expand a call to __builtin_unreachable.  We do nothing except emit
4463    a barrier saying that control flow will not pass here.
4464
4465    It is the responsibility of the program being compiled to ensure
4466    that control flow does never reach __builtin_unreachable.  */
4467 static void
4468 expand_builtin_unreachable (void)
4469 {
4470   emit_barrier ();
4471 }
4472
4473 /* Expand EXP, a call to fabs, fabsf or fabsl.
4474    Return NULL_RTX if a normal call should be emitted rather than expanding
4475    the function inline.  If convenient, the result should be placed
4476    in TARGET.  SUBTARGET may be used as the target for computing
4477    the operand.  */
4478
4479 static rtx
4480 expand_builtin_fabs (tree exp, rtx target, rtx subtarget)
4481 {
4482   machine_mode mode;
4483   tree arg;
4484   rtx op0;
4485
4486   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4487     return NULL_RTX;
4488
4489   arg = CALL_EXPR_ARG (exp, 0);
4490   CALL_EXPR_ARG (exp, 0) = arg = builtin_save_expr (arg);
4491   mode = TYPE_MODE (TREE_TYPE (arg));
4492   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4493   return expand_abs (mode, op0, target, 0, safe_from_p (target, arg, 1));
4494 }
4495
4496 /* Expand EXP, a call to copysign, copysignf, or copysignl.
4497    Return NULL is a normal call should be emitted rather than expanding the
4498    function inline.  If convenient, the result should be placed in TARGET.
4499    SUBTARGET may be used as the target for computing the operand.  */
4500
4501 static rtx
4502 expand_builtin_copysign (tree exp, rtx target, rtx subtarget)
4503 {
4504   rtx op0, op1;
4505   tree arg;
4506
4507   if (!validate_arglist (exp, REAL_TYPE, REAL_TYPE, VOID_TYPE))
4508     return NULL_RTX;
4509
4510   arg = CALL_EXPR_ARG (exp, 0);
4511   op0 = expand_expr (arg, subtarget, VOIDmode, EXPAND_NORMAL);
4512
4513   arg = CALL_EXPR_ARG (exp, 1);
4514   op1 = expand_normal (arg);
4515
4516   return expand_copysign (op0, op1, target);
4517 }
4518
4519 /* Expand a call to __builtin___clear_cache.  */
4520
4521 static rtx
4522 expand_builtin___clear_cache (tree exp)
4523 {
4524   if (!targetm.code_for_clear_cache)
4525     {
4526 #ifdef CLEAR_INSN_CACHE
4527       /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4528          does something.  Just do the default expansion to a call to
4529          __clear_cache().  */
4530       return NULL_RTX;
4531 #else
4532       /* There is no "clear_cache" insn, and __clear_cache() in libgcc
4533          does nothing.  There is no need to call it.  Do nothing.  */
4534       return const0_rtx;
4535 #endif /* CLEAR_INSN_CACHE */
4536     }
4537
4538   /* We have a "clear_cache" insn, and it will handle everything.  */
4539   tree begin, end;
4540   rtx begin_rtx, end_rtx;
4541
4542   /* We must not expand to a library call.  If we did, any
4543      fallback library function in libgcc that might contain a call to
4544      __builtin___clear_cache() would recurse infinitely.  */
4545   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
4546     {
4547       error ("both arguments to %<__builtin___clear_cache%> must be pointers");
4548       return const0_rtx;
4549     }
4550
4551   if (targetm.have_clear_cache ())
4552     {
4553       struct expand_operand ops[2];
4554
4555       begin = CALL_EXPR_ARG (exp, 0);
4556       begin_rtx = expand_expr (begin, NULL_RTX, Pmode, EXPAND_NORMAL);
4557
4558       end = CALL_EXPR_ARG (exp, 1);
4559       end_rtx = expand_expr (end, NULL_RTX, Pmode, EXPAND_NORMAL);
4560
4561       create_address_operand (&ops[0], begin_rtx);
4562       create_address_operand (&ops[1], end_rtx);
4563       if (maybe_expand_insn (targetm.code_for_clear_cache, 2, ops))
4564         return const0_rtx;
4565     }
4566   return const0_rtx;
4567 }
4568
4569 /* Given a trampoline address, make sure it satisfies TRAMPOLINE_ALIGNMENT.  */
4570
4571 static rtx
4572 round_trampoline_addr (rtx tramp)
4573 {
4574   rtx temp, addend, mask;
4575
4576   /* If we don't need too much alignment, we'll have been guaranteed
4577      proper alignment by get_trampoline_type.  */
4578   if (TRAMPOLINE_ALIGNMENT <= STACK_BOUNDARY)
4579     return tramp;
4580
4581   /* Round address up to desired boundary.  */
4582   temp = gen_reg_rtx (Pmode);
4583   addend = gen_int_mode (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT - 1, Pmode);
4584   mask = gen_int_mode (-TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT, Pmode);
4585
4586   temp  = expand_simple_binop (Pmode, PLUS, tramp, addend,
4587                                temp, 0, OPTAB_LIB_WIDEN);
4588   tramp = expand_simple_binop (Pmode, AND, temp, mask,
4589                                temp, 0, OPTAB_LIB_WIDEN);
4590
4591   return tramp;
4592 }
4593
4594 static rtx
4595 expand_builtin_init_trampoline (tree exp, bool onstack)
4596 {
4597   tree t_tramp, t_func, t_chain;
4598   rtx m_tramp, r_tramp, r_chain, tmp;
4599
4600   if (!validate_arglist (exp, POINTER_TYPE, POINTER_TYPE,
4601                          POINTER_TYPE, VOID_TYPE))
4602     return NULL_RTX;
4603
4604   t_tramp = CALL_EXPR_ARG (exp, 0);
4605   t_func = CALL_EXPR_ARG (exp, 1);
4606   t_chain = CALL_EXPR_ARG (exp, 2);
4607
4608   r_tramp = expand_normal (t_tramp);
4609   m_tramp = gen_rtx_MEM (BLKmode, r_tramp);
4610   MEM_NOTRAP_P (m_tramp) = 1;
4611
4612   /* If ONSTACK, the TRAMP argument should be the address of a field
4613      within the local function's FRAME decl.  Either way, let's see if
4614      we can fill in the MEM_ATTRs for this memory.  */
4615   if (TREE_CODE (t_tramp) == ADDR_EXPR)
4616     set_mem_attributes (m_tramp, TREE_OPERAND (t_tramp, 0), true);
4617
4618   /* Creator of a heap trampoline is responsible for making sure the
4619      address is aligned to at least STACK_BOUNDARY.  Normally malloc
4620      will ensure this anyhow.  */
4621   tmp = round_trampoline_addr (r_tramp);
4622   if (tmp != r_tramp)
4623     {
4624       m_tramp = change_address (m_tramp, BLKmode, tmp);
4625       set_mem_align (m_tramp, TRAMPOLINE_ALIGNMENT);
4626       set_mem_size (m_tramp, TRAMPOLINE_SIZE);
4627     }
4628
4629   /* The FUNC argument should be the address of the nested function.
4630      Extract the actual function decl to pass to the hook.  */
4631   gcc_assert (TREE_CODE (t_func) == ADDR_EXPR);
4632   t_func = TREE_OPERAND (t_func, 0);
4633   gcc_assert (TREE_CODE (t_func) == FUNCTION_DECL);
4634
4635   r_chain = expand_normal (t_chain);
4636
4637   /* Generate insns to initialize the trampoline.  */
4638   targetm.calls.trampoline_init (m_tramp, t_func, r_chain);
4639
4640   if (onstack)
4641     {
4642       trampolines_created = 1;
4643
4644       warning_at (DECL_SOURCE_LOCATION (t_func), OPT_Wtrampolines,
4645                   "trampoline generated for nested function %qD", t_func);
4646     }
4647
4648   return const0_rtx;
4649 }
4650
4651 static rtx
4652 expand_builtin_adjust_trampoline (tree exp)
4653 {
4654   rtx tramp;
4655
4656   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
4657     return NULL_RTX;
4658
4659   tramp = expand_normal (CALL_EXPR_ARG (exp, 0));
4660   tramp = round_trampoline_addr (tramp);
4661   if (targetm.calls.trampoline_adjust_address)
4662     tramp = targetm.calls.trampoline_adjust_address (tramp);
4663
4664   return tramp;
4665 }
4666
4667 /* Expand the call EXP to the built-in signbit, signbitf or signbitl
4668    function.  The function first checks whether the back end provides
4669    an insn to implement signbit for the respective mode.  If not, it
4670    checks whether the floating point format of the value is such that
4671    the sign bit can be extracted.  If that is not the case, error out.
4672    EXP is the expression that is a call to the builtin function; if
4673    convenient, the result should be placed in TARGET.  */
4674 static rtx
4675 expand_builtin_signbit (tree exp, rtx target)
4676 {
4677   const struct real_format *fmt;
4678   machine_mode fmode, imode, rmode;
4679   tree arg;
4680   int word, bitpos;
4681   enum insn_code icode;
4682   rtx temp;
4683   location_t loc = EXPR_LOCATION (exp);
4684
4685   if (!validate_arglist (exp, REAL_TYPE, VOID_TYPE))
4686     return NULL_RTX;
4687
4688   arg = CALL_EXPR_ARG (exp, 0);
4689   fmode = TYPE_MODE (TREE_TYPE (arg));
4690   rmode = TYPE_MODE (TREE_TYPE (exp));
4691   fmt = REAL_MODE_FORMAT (fmode);
4692
4693   arg = builtin_save_expr (arg);
4694
4695   /* Expand the argument yielding a RTX expression. */
4696   temp = expand_normal (arg);
4697
4698   /* Check if the back end provides an insn that handles signbit for the
4699      argument's mode. */
4700   icode = optab_handler (signbit_optab, fmode);
4701   if (icode != CODE_FOR_nothing)
4702     {
4703       rtx_insn *last = get_last_insn ();
4704       target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
4705       if (maybe_emit_unop_insn (icode, target, temp, UNKNOWN))
4706         return target;
4707       delete_insns_since (last);
4708     }
4709
4710   /* For floating point formats without a sign bit, implement signbit
4711      as "ARG < 0.0".  */
4712   bitpos = fmt->signbit_ro;
4713   if (bitpos < 0)
4714   {
4715     /* But we can't do this if the format supports signed zero.  */
4716     gcc_assert (!fmt->has_signed_zero || !HONOR_SIGNED_ZEROS (fmode));
4717
4718     arg = fold_build2_loc (loc, LT_EXPR, TREE_TYPE (exp), arg,
4719                        build_real (TREE_TYPE (arg), dconst0));
4720     return expand_expr (arg, target, VOIDmode, EXPAND_NORMAL);
4721   }
4722
4723   if (GET_MODE_SIZE (fmode) <= UNITS_PER_WORD)
4724     {
4725       imode = int_mode_for_mode (fmode);
4726       gcc_assert (imode != BLKmode);
4727       temp = gen_lowpart (imode, temp);
4728     }
4729   else
4730     {
4731       imode = word_mode;
4732       /* Handle targets with different FP word orders.  */
4733       if (FLOAT_WORDS_BIG_ENDIAN)
4734         word = (GET_MODE_BITSIZE (fmode) - bitpos) / BITS_PER_WORD;
4735       else
4736         word = bitpos / BITS_PER_WORD;
4737       temp = operand_subword_force (temp, word, fmode);
4738       bitpos = bitpos % BITS_PER_WORD;
4739     }
4740
4741   /* Force the intermediate word_mode (or narrower) result into a
4742      register.  This avoids attempting to create paradoxical SUBREGs
4743      of floating point modes below.  */
4744   temp = force_reg (imode, temp);
4745
4746   /* If the bitpos is within the "result mode" lowpart, the operation
4747      can be implement with a single bitwise AND.  Otherwise, we need
4748      a right shift and an AND.  */
4749
4750   if (bitpos < GET_MODE_BITSIZE (rmode))
4751     {
4752       wide_int mask = wi::set_bit_in_zero (bitpos, GET_MODE_PRECISION (rmode));
4753
4754       if (GET_MODE_SIZE (imode) > GET_MODE_SIZE (rmode))
4755         temp = gen_lowpart (rmode, temp);
4756       temp = expand_binop (rmode, and_optab, temp,
4757                            immed_wide_int_const (mask, rmode),
4758                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
4759     }
4760   else
4761     {
4762       /* Perform a logical right shift to place the signbit in the least
4763          significant bit, then truncate the result to the desired mode
4764          and mask just this bit.  */
4765       temp = expand_shift (RSHIFT_EXPR, imode, temp, bitpos, NULL_RTX, 1);
4766       temp = gen_lowpart (rmode, temp);
4767       temp = expand_binop (rmode, and_optab, temp, const1_rtx,
4768                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
4769     }
4770
4771   return temp;
4772 }
4773
4774 /* Expand fork or exec calls.  TARGET is the desired target of the
4775    call.  EXP is the call. FN is the
4776    identificator of the actual function.  IGNORE is nonzero if the
4777    value is to be ignored.  */
4778
4779 static rtx
4780 expand_builtin_fork_or_exec (tree fn, tree exp, rtx target, int ignore)
4781 {
4782   tree id, decl;
4783   tree call;
4784
4785   /* If we are not profiling, just call the function.  */
4786   if (!profile_arc_flag)
4787     return NULL_RTX;
4788
4789   /* Otherwise call the wrapper.  This should be equivalent for the rest of
4790      compiler, so the code does not diverge, and the wrapper may run the
4791      code necessary for keeping the profiling sane.  */
4792
4793   switch (DECL_FUNCTION_CODE (fn))
4794     {
4795     case BUILT_IN_FORK:
4796       id = get_identifier ("__gcov_fork");
4797       break;
4798
4799     case BUILT_IN_EXECL:
4800       id = get_identifier ("__gcov_execl");
4801       break;
4802
4803     case BUILT_IN_EXECV:
4804       id = get_identifier ("__gcov_execv");
4805       break;
4806
4807     case BUILT_IN_EXECLP:
4808       id = get_identifier ("__gcov_execlp");
4809       break;
4810
4811     case BUILT_IN_EXECLE:
4812       id = get_identifier ("__gcov_execle");
4813       break;
4814
4815     case BUILT_IN_EXECVP:
4816       id = get_identifier ("__gcov_execvp");
4817       break;
4818
4819     case BUILT_IN_EXECVE:
4820       id = get_identifier ("__gcov_execve");
4821       break;
4822
4823     default:
4824       gcc_unreachable ();
4825     }
4826
4827   decl = build_decl (DECL_SOURCE_LOCATION (fn),
4828                      FUNCTION_DECL, id, TREE_TYPE (fn));
4829   DECL_EXTERNAL (decl) = 1;
4830   TREE_PUBLIC (decl) = 1;
4831   DECL_ARTIFICIAL (decl) = 1;
4832   TREE_NOTHROW (decl) = 1;
4833   DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4834   DECL_VISIBILITY_SPECIFIED (decl) = 1;
4835   call = rewrite_call_expr (EXPR_LOCATION (exp), exp, 0, decl, 0);
4836   return expand_call (call, target, ignore);
4837  }
4838
4839
4840 \f
4841 /* Reconstitute a mode for a __sync intrinsic operation.  Since the type of
4842    the pointer in these functions is void*, the tree optimizers may remove
4843    casts.  The mode computed in expand_builtin isn't reliable either, due
4844    to __sync_bool_compare_and_swap.
4845
4846    FCODE_DIFF should be fcode - base, where base is the FOO_1 code for the
4847    group of builtins.  This gives us log2 of the mode size.  */
4848
4849 static inline machine_mode
4850 get_builtin_sync_mode (int fcode_diff)
4851 {
4852   /* The size is not negotiable, so ask not to get BLKmode in return
4853      if the target indicates that a smaller size would be better.  */
4854   return mode_for_size (BITS_PER_UNIT << fcode_diff, MODE_INT, 0);
4855 }
4856
4857 /* Expand the memory expression LOC and return the appropriate memory operand
4858    for the builtin_sync operations.  */
4859
4860 static rtx
4861 get_builtin_sync_mem (tree loc, machine_mode mode)
4862 {
4863   rtx addr, mem;
4864
4865   addr = expand_expr (loc, NULL_RTX, ptr_mode, EXPAND_SUM);
4866   addr = convert_memory_address (Pmode, addr);
4867
4868   /* Note that we explicitly do not want any alias information for this
4869      memory, so that we kill all other live memories.  Otherwise we don't
4870      satisfy the full barrier semantics of the intrinsic.  */
4871   mem = validize_mem (gen_rtx_MEM (mode, addr));
4872
4873   /* The alignment needs to be at least according to that of the mode.  */
4874   set_mem_align (mem, MAX (GET_MODE_ALIGNMENT (mode),
4875                            get_pointer_alignment (loc)));
4876   set_mem_alias_set (mem, ALIAS_SET_MEMORY_BARRIER);
4877   MEM_VOLATILE_P (mem) = 1;
4878
4879   return mem;
4880 }
4881
4882 /* Make sure an argument is in the right mode.
4883    EXP is the tree argument.
4884    MODE is the mode it should be in.  */
4885
4886 static rtx
4887 expand_expr_force_mode (tree exp, machine_mode mode)
4888 {
4889   rtx val;
4890   machine_mode old_mode;
4891
4892   val = expand_expr (exp, NULL_RTX, mode, EXPAND_NORMAL);
4893   /* If VAL is promoted to a wider mode, convert it back to MODE.  Take care
4894      of CONST_INTs, where we know the old_mode only from the call argument.  */
4895
4896   old_mode = GET_MODE (val);
4897   if (old_mode == VOIDmode)
4898     old_mode = TYPE_MODE (TREE_TYPE (exp));
4899   val = convert_modes (mode, old_mode, val, 1);
4900   return val;
4901 }
4902
4903
4904 /* Expand the __sync_xxx_and_fetch and __sync_fetch_and_xxx intrinsics.
4905    EXP is the CALL_EXPR.  CODE is the rtx code
4906    that corresponds to the arithmetic or logical operation from the name;
4907    an exception here is that NOT actually means NAND.  TARGET is an optional
4908    place for us to store the results; AFTER is true if this is the
4909    fetch_and_xxx form.  */
4910
4911 static rtx
4912 expand_builtin_sync_operation (machine_mode mode, tree exp,
4913                                enum rtx_code code, bool after,
4914                                rtx target)
4915 {
4916   rtx val, mem;
4917   location_t loc = EXPR_LOCATION (exp);
4918
4919   if (code == NOT && warn_sync_nand)
4920     {
4921       tree fndecl = get_callee_fndecl (exp);
4922       enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
4923
4924       static bool warned_f_a_n, warned_n_a_f;
4925
4926       switch (fcode)
4927         {
4928         case BUILT_IN_SYNC_FETCH_AND_NAND_1:
4929         case BUILT_IN_SYNC_FETCH_AND_NAND_2:
4930         case BUILT_IN_SYNC_FETCH_AND_NAND_4:
4931         case BUILT_IN_SYNC_FETCH_AND_NAND_8:
4932         case BUILT_IN_SYNC_FETCH_AND_NAND_16:
4933           if (warned_f_a_n)
4934             break;
4935
4936           fndecl = builtin_decl_implicit (BUILT_IN_SYNC_FETCH_AND_NAND_N);
4937           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
4938           warned_f_a_n = true;
4939           break;
4940
4941         case BUILT_IN_SYNC_NAND_AND_FETCH_1:
4942         case BUILT_IN_SYNC_NAND_AND_FETCH_2:
4943         case BUILT_IN_SYNC_NAND_AND_FETCH_4:
4944         case BUILT_IN_SYNC_NAND_AND_FETCH_8:
4945         case BUILT_IN_SYNC_NAND_AND_FETCH_16:
4946           if (warned_n_a_f)
4947             break;
4948
4949          fndecl = builtin_decl_implicit (BUILT_IN_SYNC_NAND_AND_FETCH_N);
4950           inform (loc, "%qD changed semantics in GCC 4.4", fndecl);
4951           warned_n_a_f = true;
4952           break;
4953
4954         default:
4955           gcc_unreachable ();
4956         }
4957     }
4958
4959   /* Expand the operands.  */
4960   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
4961   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
4962
4963   return expand_atomic_fetch_op (target, mem, val, code, MEMMODEL_SYNC_SEQ_CST,
4964                                  after);
4965 }
4966
4967 /* Expand the __sync_val_compare_and_swap and __sync_bool_compare_and_swap
4968    intrinsics. EXP is the CALL_EXPR.  IS_BOOL is
4969    true if this is the boolean form.  TARGET is a place for us to store the
4970    results; this is NOT optional if IS_BOOL is true.  */
4971
4972 static rtx
4973 expand_builtin_compare_and_swap (machine_mode mode, tree exp,
4974                                  bool is_bool, rtx target)
4975 {
4976   rtx old_val, new_val, mem;
4977   rtx *pbool, *poval;
4978
4979   /* Expand the operands.  */
4980   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
4981   old_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
4982   new_val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode);
4983
4984   pbool = poval = NULL;
4985   if (target != const0_rtx)
4986     {
4987       if (is_bool)
4988         pbool = &target;
4989       else
4990         poval = &target;
4991     }
4992   if (!expand_atomic_compare_and_swap (pbool, poval, mem, old_val, new_val,
4993                                        false, MEMMODEL_SYNC_SEQ_CST,
4994                                        MEMMODEL_SYNC_SEQ_CST))
4995     return NULL_RTX;
4996
4997   return target;
4998 }
4999
5000 /* Expand the __sync_lock_test_and_set intrinsic.  Note that the most
5001    general form is actually an atomic exchange, and some targets only
5002    support a reduced form with the second argument being a constant 1.
5003    EXP is the CALL_EXPR; TARGET is an optional place for us to store
5004    the results.  */
5005
5006 static rtx
5007 expand_builtin_sync_lock_test_and_set (machine_mode mode, tree exp,
5008                                        rtx target)
5009 {
5010   rtx val, mem;
5011
5012   /* Expand the operands.  */
5013   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5014   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5015
5016   return expand_sync_lock_test_and_set (target, mem, val);
5017 }
5018
5019 /* Expand the __sync_lock_release intrinsic.  EXP is the CALL_EXPR.  */
5020
5021 static void
5022 expand_builtin_sync_lock_release (machine_mode mode, tree exp)
5023 {
5024   rtx mem;
5025
5026   /* Expand the operands.  */
5027   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5028
5029   expand_atomic_store (mem, const0_rtx, MEMMODEL_SYNC_RELEASE, true);
5030 }
5031
5032 /* Given an integer representing an ``enum memmodel'', verify its
5033    correctness and return the memory model enum.  */
5034
5035 static enum memmodel
5036 get_memmodel (tree exp)
5037 {
5038   rtx op;
5039   unsigned HOST_WIDE_INT val;
5040   source_location loc
5041     = expansion_point_location_if_in_system_header (input_location);
5042
5043   /* If the parameter is not a constant, it's a run time value so we'll just
5044      convert it to MEMMODEL_SEQ_CST to avoid annoying runtime checking.  */
5045   if (TREE_CODE (exp) != INTEGER_CST)
5046     return MEMMODEL_SEQ_CST;
5047
5048   op = expand_normal (exp);
5049
5050   val = INTVAL (op);
5051   if (targetm.memmodel_check)
5052     val = targetm.memmodel_check (val);
5053   else if (val & ~MEMMODEL_MASK)
5054     {
5055       warning_at (loc, OPT_Winvalid_memory_model,
5056                   "unknown architecture specifier in memory model to builtin");
5057       return MEMMODEL_SEQ_CST;
5058     }
5059
5060   /* Should never see a user explicit SYNC memodel model, so >= LAST works. */
5061   if (memmodel_base (val) >= MEMMODEL_LAST)
5062     {
5063       warning_at (loc, OPT_Winvalid_memory_model,
5064                   "invalid memory model argument to builtin");
5065       return MEMMODEL_SEQ_CST;
5066     }
5067
5068   /* Workaround for Bugzilla 59448. GCC doesn't track consume properly, so
5069      be conservative and promote consume to acquire.  */
5070   if (val == MEMMODEL_CONSUME)
5071     val = MEMMODEL_ACQUIRE;
5072
5073   return (enum memmodel) val;
5074 }
5075
5076 /* Expand the __atomic_exchange intrinsic:
5077         TYPE __atomic_exchange (TYPE *object, TYPE desired, enum memmodel)
5078    EXP is the CALL_EXPR.
5079    TARGET is an optional place for us to store the results.  */
5080
5081 static rtx
5082 expand_builtin_atomic_exchange (machine_mode mode, tree exp, rtx target)
5083 {
5084   rtx val, mem;
5085   enum memmodel model;
5086
5087   model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5088
5089   if (!flag_inline_atomics)
5090     return NULL_RTX;
5091
5092   /* Expand the operands.  */
5093   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5094   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5095
5096   return expand_atomic_exchange (target, mem, val, model);
5097 }
5098
5099 /* Expand the __atomic_compare_exchange intrinsic:
5100         bool __atomic_compare_exchange (TYPE *object, TYPE *expect,
5101                                         TYPE desired, BOOL weak,
5102                                         enum memmodel success,
5103                                         enum memmodel failure)
5104    EXP is the CALL_EXPR.
5105    TARGET is an optional place for us to store the results.  */
5106
5107 static rtx
5108 expand_builtin_atomic_compare_exchange (machine_mode mode, tree exp,
5109                                         rtx target)
5110 {
5111   rtx expect, desired, mem, oldval;
5112   rtx_code_label *label;
5113   enum memmodel success, failure;
5114   tree weak;
5115   bool is_weak;
5116   source_location loc
5117     = expansion_point_location_if_in_system_header (input_location);
5118
5119   success = get_memmodel (CALL_EXPR_ARG (exp, 4));
5120   failure = get_memmodel (CALL_EXPR_ARG (exp, 5));
5121
5122   if (failure > success)
5123     {
5124       warning_at (loc, OPT_Winvalid_memory_model,
5125                   "failure memory model cannot be stronger than success "
5126                   "memory model for %<__atomic_compare_exchange%>");
5127       success = MEMMODEL_SEQ_CST;
5128     }
5129
5130   if (is_mm_release (failure) || is_mm_acq_rel (failure))
5131     {
5132       warning_at (loc, OPT_Winvalid_memory_model,
5133                   "invalid failure memory model for "
5134                   "%<__atomic_compare_exchange%>");
5135       failure = MEMMODEL_SEQ_CST;
5136       success = MEMMODEL_SEQ_CST;
5137     }
5138
5139
5140   if (!flag_inline_atomics)
5141     return NULL_RTX;
5142
5143   /* Expand the operands.  */
5144   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5145
5146   expect = expand_normal (CALL_EXPR_ARG (exp, 1));
5147   expect = convert_memory_address (Pmode, expect);
5148   expect = gen_rtx_MEM (mode, expect);
5149   desired = expand_expr_force_mode (CALL_EXPR_ARG (exp, 2), mode);
5150
5151   weak = CALL_EXPR_ARG (exp, 3);
5152   is_weak = false;
5153   if (tree_fits_shwi_p (weak) && tree_to_shwi (weak) != 0)
5154     is_weak = true;
5155
5156   if (target == const0_rtx)
5157     target = NULL;
5158
5159   /* Lest the rtl backend create a race condition with an imporoper store
5160      to memory, always create a new pseudo for OLDVAL.  */
5161   oldval = NULL;
5162
5163   if (!expand_atomic_compare_and_swap (&target, &oldval, mem, expect, desired,
5164                                        is_weak, success, failure))
5165     return NULL_RTX;
5166
5167   /* Conditionally store back to EXPECT, lest we create a race condition
5168      with an improper store to memory.  */
5169   /* ??? With a rearrangement of atomics at the gimple level, we can handle
5170      the normal case where EXPECT is totally private, i.e. a register.  At
5171      which point the store can be unconditional.  */
5172   label = gen_label_rtx ();
5173   emit_cmp_and_jump_insns (target, const0_rtx, NE, NULL,
5174                            GET_MODE (target), 1, label);
5175   emit_move_insn (expect, oldval);
5176   emit_label (label);
5177
5178   return target;
5179 }
5180
5181 /* Expand the __atomic_load intrinsic:
5182         TYPE __atomic_load (TYPE *object, enum memmodel)
5183    EXP is the CALL_EXPR.
5184    TARGET is an optional place for us to store the results.  */
5185
5186 static rtx
5187 expand_builtin_atomic_load (machine_mode mode, tree exp, rtx target)
5188 {
5189   rtx mem;
5190   enum memmodel model;
5191
5192   model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5193   if (is_mm_release (model) || is_mm_acq_rel (model))
5194     {
5195       source_location loc
5196         = expansion_point_location_if_in_system_header (input_location);
5197       warning_at (loc, OPT_Winvalid_memory_model,
5198                   "invalid memory model for %<__atomic_load%>");
5199       model = MEMMODEL_SEQ_CST;
5200     }
5201
5202   if (!flag_inline_atomics)
5203     return NULL_RTX;
5204
5205   /* Expand the operand.  */
5206   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5207
5208   return expand_atomic_load (target, mem, model);
5209 }
5210
5211
5212 /* Expand the __atomic_store intrinsic:
5213         void __atomic_store (TYPE *object, TYPE desired, enum memmodel)
5214    EXP is the CALL_EXPR.
5215    TARGET is an optional place for us to store the results.  */
5216
5217 static rtx
5218 expand_builtin_atomic_store (machine_mode mode, tree exp)
5219 {
5220   rtx mem, val;
5221   enum memmodel model;
5222
5223   model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5224   if (!(is_mm_relaxed (model) || is_mm_seq_cst (model)
5225         || is_mm_release (model)))
5226     {
5227       source_location loc
5228         = expansion_point_location_if_in_system_header (input_location);
5229       warning_at (loc, OPT_Winvalid_memory_model,
5230                   "invalid memory model for %<__atomic_store%>");
5231       model = MEMMODEL_SEQ_CST;
5232     }
5233
5234   if (!flag_inline_atomics)
5235     return NULL_RTX;
5236
5237   /* Expand the operands.  */
5238   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5239   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5240
5241   return expand_atomic_store (mem, val, model, false);
5242 }
5243
5244 /* Expand the __atomic_fetch_XXX intrinsic:
5245         TYPE __atomic_fetch_XXX (TYPE *object, TYPE val, enum memmodel)
5246    EXP is the CALL_EXPR.
5247    TARGET is an optional place for us to store the results.
5248    CODE is the operation, PLUS, MINUS, ADD, XOR, or IOR.
5249    FETCH_AFTER is true if returning the result of the operation.
5250    FETCH_AFTER is false if returning the value before the operation.
5251    IGNORE is true if the result is not used.
5252    EXT_CALL is the correct builtin for an external call if this cannot be
5253    resolved to an instruction sequence.  */
5254
5255 static rtx
5256 expand_builtin_atomic_fetch_op (machine_mode mode, tree exp, rtx target,
5257                                 enum rtx_code code, bool fetch_after,
5258                                 bool ignore, enum built_in_function ext_call)
5259 {
5260   rtx val, mem, ret;
5261   enum memmodel model;
5262   tree fndecl;
5263   tree addr;
5264
5265   model = get_memmodel (CALL_EXPR_ARG (exp, 2));
5266
5267   /* Expand the operands.  */
5268   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5269   val = expand_expr_force_mode (CALL_EXPR_ARG (exp, 1), mode);
5270
5271   /* Only try generating instructions if inlining is turned on.  */
5272   if (flag_inline_atomics)
5273     {
5274       ret = expand_atomic_fetch_op (target, mem, val, code, model, fetch_after);
5275       if (ret)
5276         return ret;
5277     }
5278
5279   /* Return if a different routine isn't needed for the library call.  */
5280   if (ext_call == BUILT_IN_NONE)
5281     return NULL_RTX;
5282
5283   /* Change the call to the specified function.  */
5284   fndecl = get_callee_fndecl (exp);
5285   addr = CALL_EXPR_FN (exp);
5286   STRIP_NOPS (addr);
5287
5288   gcc_assert (TREE_OPERAND (addr, 0) == fndecl);
5289   TREE_OPERAND (addr, 0) = builtin_decl_explicit (ext_call);
5290
5291   /* Expand the call here so we can emit trailing code.  */
5292   ret = expand_call (exp, target, ignore);
5293
5294   /* Replace the original function just in case it matters.  */
5295   TREE_OPERAND (addr, 0) = fndecl;
5296
5297   /* Then issue the arithmetic correction to return the right result.  */
5298   if (!ignore)
5299     {
5300       if (code == NOT)
5301         {
5302           ret = expand_simple_binop (mode, AND, ret, val, NULL_RTX, true,
5303                                      OPTAB_LIB_WIDEN);
5304           ret = expand_simple_unop (mode, NOT, ret, target, true);
5305         }
5306       else
5307         ret = expand_simple_binop (mode, code, ret, val, target, true,
5308                                    OPTAB_LIB_WIDEN);
5309     }
5310   return ret;
5311 }
5312
5313 /* Expand an atomic clear operation.
5314         void _atomic_clear (BOOL *obj, enum memmodel)
5315    EXP is the call expression.  */
5316
5317 static rtx
5318 expand_builtin_atomic_clear (tree exp)
5319 {
5320   machine_mode mode;
5321   rtx mem, ret;
5322   enum memmodel model;
5323
5324   mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0);
5325   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5326   model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5327
5328   if (is_mm_consume (model) || is_mm_acquire (model) || is_mm_acq_rel (model))
5329     {
5330       source_location loc
5331         = expansion_point_location_if_in_system_header (input_location);
5332       warning_at (loc, OPT_Winvalid_memory_model,
5333                   "invalid memory model for %<__atomic_store%>");
5334       model = MEMMODEL_SEQ_CST;
5335     }
5336
5337   /* Try issuing an __atomic_store, and allow fallback to __sync_lock_release.
5338      Failing that, a store is issued by __atomic_store.  The only way this can
5339      fail is if the bool type is larger than a word size.  Unlikely, but
5340      handle it anyway for completeness.  Assume a single threaded model since
5341      there is no atomic support in this case, and no barriers are required.  */
5342   ret = expand_atomic_store (mem, const0_rtx, model, true);
5343   if (!ret)
5344     emit_move_insn (mem, const0_rtx);
5345   return const0_rtx;
5346 }
5347
5348 /* Expand an atomic test_and_set operation.
5349         bool _atomic_test_and_set (BOOL *obj, enum memmodel)
5350    EXP is the call expression.  */
5351
5352 static rtx
5353 expand_builtin_atomic_test_and_set (tree exp, rtx target)
5354 {
5355   rtx mem;
5356   enum memmodel model;
5357   machine_mode mode;
5358
5359   mode = mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0);
5360   mem = get_builtin_sync_mem (CALL_EXPR_ARG (exp, 0), mode);
5361   model = get_memmodel (CALL_EXPR_ARG (exp, 1));
5362
5363   return expand_atomic_test_and_set (target, mem, model);
5364 }
5365
5366
5367 /* Return true if (optional) argument ARG1 of size ARG0 is always lock free on
5368    this architecture.  If ARG1 is NULL, use typical alignment for size ARG0.  */
5369
5370 static tree
5371 fold_builtin_atomic_always_lock_free (tree arg0, tree arg1)
5372 {
5373   int size;
5374   machine_mode mode;
5375   unsigned int mode_align, type_align;
5376
5377   if (TREE_CODE (arg0) != INTEGER_CST)
5378     return NULL_TREE;
5379
5380   size = INTVAL (expand_normal (arg0)) * BITS_PER_UNIT;
5381   mode = mode_for_size (size, MODE_INT, 0);
5382   mode_align = GET_MODE_ALIGNMENT (mode);
5383
5384   if (TREE_CODE (arg1) == INTEGER_CST)
5385     {
5386       unsigned HOST_WIDE_INT val = UINTVAL (expand_normal (arg1));
5387
5388       /* Either this argument is null, or it's a fake pointer encoding
5389          the alignment of the object.  */
5390       val = val & -val;
5391       val *= BITS_PER_UNIT;
5392
5393       if (val == 0 || mode_align < val)
5394         type_align = mode_align;
5395       else
5396         type_align = val;
5397     }
5398   else
5399     {
5400       tree ttype = TREE_TYPE (arg1);
5401
5402       /* This function is usually invoked and folded immediately by the front
5403          end before anything else has a chance to look at it.  The pointer
5404          parameter at this point is usually cast to a void *, so check for that
5405          and look past the cast.  */
5406       if (CONVERT_EXPR_P (arg1) && POINTER_TYPE_P (ttype)
5407           && VOID_TYPE_P (TREE_TYPE (ttype)))
5408         arg1 = TREE_OPERAND (arg1, 0);
5409
5410       ttype = TREE_TYPE (arg1);
5411       gcc_assert (POINTER_TYPE_P (ttype));
5412
5413       /* Get the underlying type of the object.  */
5414       ttype = TREE_TYPE (ttype);
5415       type_align = TYPE_ALIGN (ttype);
5416     }
5417
5418   /* If the object has smaller alignment, the lock free routines cannot
5419      be used.  */
5420   if (type_align < mode_align)
5421     return boolean_false_node;
5422
5423   /* Check if a compare_and_swap pattern exists for the mode which represents
5424      the required size.  The pattern is not allowed to fail, so the existence
5425      of the pattern indicates support is present.  */
5426   if (can_compare_and_swap_p (mode, true))
5427     return boolean_true_node;
5428   else
5429     return boolean_false_node;
5430 }
5431
5432 /* Return true if the parameters to call EXP represent an object which will
5433    always generate lock free instructions.  The first argument represents the
5434    size of the object, and the second parameter is a pointer to the object
5435    itself.  If NULL is passed for the object, then the result is based on
5436    typical alignment for an object of the specified size.  Otherwise return
5437    false.  */
5438
5439 static rtx
5440 expand_builtin_atomic_always_lock_free (tree exp)
5441 {
5442   tree size;
5443   tree arg0 = CALL_EXPR_ARG (exp, 0);
5444   tree arg1 = CALL_EXPR_ARG (exp, 1);
5445
5446   if (TREE_CODE (arg0) != INTEGER_CST)
5447     {
5448       error ("non-constant argument 1 to __atomic_always_lock_free");
5449       return const0_rtx;
5450     }
5451
5452   size = fold_builtin_atomic_always_lock_free (arg0, arg1);
5453   if (size == boolean_true_node)
5454     return const1_rtx;
5455   return const0_rtx;
5456 }
5457
5458 /* Return a one or zero if it can be determined that object ARG1 of size ARG
5459    is lock free on this architecture.  */
5460
5461 static tree
5462 fold_builtin_atomic_is_lock_free (tree arg0, tree arg1)
5463 {
5464   if (!flag_inline_atomics)
5465     return NULL_TREE;
5466
5467   /* If it isn't always lock free, don't generate a result.  */
5468   if (fold_builtin_atomic_always_lock_free (arg0, arg1) == boolean_true_node)
5469     return boolean_true_node;
5470
5471   return NULL_TREE;
5472 }
5473
5474 /* Return true if the parameters to call EXP represent an object which will
5475    always generate lock free instructions.  The first argument represents the
5476    size of the object, and the second parameter is a pointer to the object
5477    itself.  If NULL is passed for the object, then the result is based on
5478    typical alignment for an object of the specified size.  Otherwise return
5479    NULL*/
5480
5481 static rtx
5482 expand_builtin_atomic_is_lock_free (tree exp)
5483 {
5484   tree size;
5485   tree arg0 = CALL_EXPR_ARG (exp, 0);
5486   tree arg1 = CALL_EXPR_ARG (exp, 1);
5487
5488   if (!INTEGRAL_TYPE_P (TREE_TYPE (arg0)))
5489     {
5490       error ("non-integer argument 1 to __atomic_is_lock_free");
5491       return NULL_RTX;
5492     }
5493
5494   if (!flag_inline_atomics)
5495     return NULL_RTX;
5496
5497   /* If the value is known at compile time, return the RTX for it.  */
5498   size = fold_builtin_atomic_is_lock_free (arg0, arg1);
5499   if (size == boolean_true_node)
5500     return const1_rtx;
5501
5502   return NULL_RTX;
5503 }
5504
5505 /* Expand the __atomic_thread_fence intrinsic:
5506         void __atomic_thread_fence (enum memmodel)
5507    EXP is the CALL_EXPR.  */
5508
5509 static void
5510 expand_builtin_atomic_thread_fence (tree exp)
5511 {
5512   enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0));
5513   expand_mem_thread_fence (model);
5514 }
5515
5516 /* Expand the __atomic_signal_fence intrinsic:
5517         void __atomic_signal_fence (enum memmodel)
5518    EXP is the CALL_EXPR.  */
5519
5520 static void
5521 expand_builtin_atomic_signal_fence (tree exp)
5522 {
5523   enum memmodel model = get_memmodel (CALL_EXPR_ARG (exp, 0));
5524   expand_mem_signal_fence (model);
5525 }
5526
5527 /* Expand the __sync_synchronize intrinsic.  */
5528
5529 static void
5530 expand_builtin_sync_synchronize (void)
5531 {
5532   expand_mem_thread_fence (MEMMODEL_SYNC_SEQ_CST);
5533 }
5534
5535 static rtx
5536 expand_builtin_thread_pointer (tree exp, rtx target)
5537 {
5538   enum insn_code icode;
5539   if (!validate_arglist (exp, VOID_TYPE))
5540     return const0_rtx;
5541   icode = direct_optab_handler (get_thread_pointer_optab, Pmode);
5542   if (icode != CODE_FOR_nothing)
5543     {
5544       struct expand_operand op;
5545       /* If the target is not sutitable then create a new target. */
5546       if (target == NULL_RTX
5547           || !REG_P (target)
5548           || GET_MODE (target) != Pmode)
5549         target = gen_reg_rtx (Pmode);
5550       create_output_operand (&op, target, Pmode);
5551       expand_insn (icode, 1, &op);
5552       return target;
5553     }
5554   error ("__builtin_thread_pointer is not supported on this target");
5555   return const0_rtx;
5556 }
5557
5558 static void
5559 expand_builtin_set_thread_pointer (tree exp)
5560 {
5561   enum insn_code icode;
5562   if (!validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5563     return;
5564   icode = direct_optab_handler (set_thread_pointer_optab, Pmode);
5565   if (icode != CODE_FOR_nothing)
5566     {
5567       struct expand_operand op;
5568       rtx val = expand_expr (CALL_EXPR_ARG (exp, 0), NULL_RTX,
5569                              Pmode, EXPAND_NORMAL);
5570       create_input_operand (&op, val, Pmode);
5571       expand_insn (icode, 1, &op);
5572       return;
5573     }
5574   error ("__builtin_set_thread_pointer is not supported on this target");
5575 }
5576
5577 \f
5578 /* Emit code to restore the current value of stack.  */
5579
5580 static void
5581 expand_stack_restore (tree var)
5582 {
5583   rtx_insn *prev;
5584   rtx sa = expand_normal (var);
5585
5586   sa = convert_memory_address (Pmode, sa);
5587
5588   prev = get_last_insn ();
5589   emit_stack_restore (SAVE_BLOCK, sa);
5590
5591   record_new_stack_level ();
5592
5593   fixup_args_size_notes (prev, get_last_insn (), 0);
5594 }
5595
5596 /* Emit code to save the current value of stack.  */
5597
5598 static rtx
5599 expand_stack_save (void)
5600 {
5601   rtx ret = NULL_RTX;
5602
5603   emit_stack_save (SAVE_BLOCK, &ret);
5604   return ret;
5605 }
5606
5607
5608 /* Expand an expression EXP that calls a built-in function,
5609    with result going to TARGET if that's convenient
5610    (and in mode MODE if that's convenient).
5611    SUBTARGET may be used as the target for computing one of EXP's operands.
5612    IGNORE is nonzero if the value is to be ignored.  */
5613
5614 rtx
5615 expand_builtin (tree exp, rtx target, rtx subtarget, machine_mode mode,
5616                 int ignore)
5617 {
5618   tree fndecl = get_callee_fndecl (exp);
5619   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
5620   machine_mode target_mode = TYPE_MODE (TREE_TYPE (exp));
5621   int flags;
5622
5623   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
5624     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
5625
5626   /* When ASan is enabled, we don't want to expand some memory/string
5627      builtins and rely on libsanitizer's hooks.  This allows us to avoid
5628      redundant checks and be sure, that possible overflow will be detected
5629      by ASan.  */
5630
5631   if ((flag_sanitize & SANITIZE_ADDRESS) && asan_intercepted_p (fcode))
5632     return expand_call (exp, target, ignore);
5633
5634   /* When not optimizing, generate calls to library functions for a certain
5635      set of builtins.  */
5636   if (!optimize
5637       && !called_as_built_in (fndecl)
5638       && fcode != BUILT_IN_FORK
5639       && fcode != BUILT_IN_EXECL
5640       && fcode != BUILT_IN_EXECV
5641       && fcode != BUILT_IN_EXECLP
5642       && fcode != BUILT_IN_EXECLE
5643       && fcode != BUILT_IN_EXECVP
5644       && fcode != BUILT_IN_EXECVE
5645       && fcode != BUILT_IN_ALLOCA
5646       && fcode != BUILT_IN_ALLOCA_WITH_ALIGN
5647       && fcode != BUILT_IN_FREE
5648       && fcode != BUILT_IN_CHKP_SET_PTR_BOUNDS
5649       && fcode != BUILT_IN_CHKP_INIT_PTR_BOUNDS
5650       && fcode != BUILT_IN_CHKP_NULL_PTR_BOUNDS
5651       && fcode != BUILT_IN_CHKP_COPY_PTR_BOUNDS
5652       && fcode != BUILT_IN_CHKP_NARROW_PTR_BOUNDS
5653       && fcode != BUILT_IN_CHKP_STORE_PTR_BOUNDS
5654       && fcode != BUILT_IN_CHKP_CHECK_PTR_LBOUNDS
5655       && fcode != BUILT_IN_CHKP_CHECK_PTR_UBOUNDS
5656       && fcode != BUILT_IN_CHKP_CHECK_PTR_BOUNDS
5657       && fcode != BUILT_IN_CHKP_GET_PTR_LBOUND
5658       && fcode != BUILT_IN_CHKP_GET_PTR_UBOUND
5659       && fcode != BUILT_IN_CHKP_BNDRET)
5660     return expand_call (exp, target, ignore);
5661
5662   /* The built-in function expanders test for target == const0_rtx
5663      to determine whether the function's result will be ignored.  */
5664   if (ignore)
5665     target = const0_rtx;
5666
5667   /* If the result of a pure or const built-in function is ignored, and
5668      none of its arguments are volatile, we can avoid expanding the
5669      built-in call and just evaluate the arguments for side-effects.  */
5670   if (target == const0_rtx
5671       && ((flags = flags_from_decl_or_type (fndecl)) & (ECF_CONST | ECF_PURE))
5672       && !(flags & ECF_LOOPING_CONST_OR_PURE))
5673     {
5674       bool volatilep = false;
5675       tree arg;
5676       call_expr_arg_iterator iter;
5677
5678       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5679         if (TREE_THIS_VOLATILE (arg))
5680           {
5681             volatilep = true;
5682             break;
5683           }
5684
5685       if (! volatilep)
5686         {
5687           FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
5688             expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
5689           return const0_rtx;
5690         }
5691     }
5692
5693   /* expand_builtin_with_bounds is supposed to be used for
5694      instrumented builtin calls.  */
5695   gcc_assert (!CALL_WITH_BOUNDS_P (exp));
5696
5697   switch (fcode)
5698     {
5699     CASE_FLT_FN (BUILT_IN_FABS):
5700     case BUILT_IN_FABSD32:
5701     case BUILT_IN_FABSD64:
5702     case BUILT_IN_FABSD128:
5703       target = expand_builtin_fabs (exp, target, subtarget);
5704       if (target)
5705         return target;
5706       break;
5707
5708     CASE_FLT_FN (BUILT_IN_COPYSIGN):
5709       target = expand_builtin_copysign (exp, target, subtarget);
5710       if (target)
5711         return target;
5712       break;
5713
5714       /* Just do a normal library call if we were unable to fold
5715          the values.  */
5716     CASE_FLT_FN (BUILT_IN_CABS):
5717       break;
5718
5719     CASE_FLT_FN (BUILT_IN_FMA):
5720       target = expand_builtin_mathfn_ternary (exp, target, subtarget);
5721       if (target)
5722         return target;
5723       break;
5724
5725     CASE_FLT_FN (BUILT_IN_ILOGB):
5726       if (! flag_unsafe_math_optimizations)
5727         break;
5728     CASE_FLT_FN (BUILT_IN_ISINF):
5729     CASE_FLT_FN (BUILT_IN_FINITE):
5730     case BUILT_IN_ISFINITE:
5731     case BUILT_IN_ISNORMAL:
5732       target = expand_builtin_interclass_mathfn (exp, target);
5733       if (target)
5734         return target;
5735       break;
5736
5737     CASE_FLT_FN (BUILT_IN_ICEIL):
5738     CASE_FLT_FN (BUILT_IN_LCEIL):
5739     CASE_FLT_FN (BUILT_IN_LLCEIL):
5740     CASE_FLT_FN (BUILT_IN_LFLOOR):
5741     CASE_FLT_FN (BUILT_IN_IFLOOR):
5742     CASE_FLT_FN (BUILT_IN_LLFLOOR):
5743       target = expand_builtin_int_roundingfn (exp, target);
5744       if (target)
5745         return target;
5746       break;
5747
5748     CASE_FLT_FN (BUILT_IN_IRINT):
5749     CASE_FLT_FN (BUILT_IN_LRINT):
5750     CASE_FLT_FN (BUILT_IN_LLRINT):
5751     CASE_FLT_FN (BUILT_IN_IROUND):
5752     CASE_FLT_FN (BUILT_IN_LROUND):
5753     CASE_FLT_FN (BUILT_IN_LLROUND):
5754       target = expand_builtin_int_roundingfn_2 (exp, target);
5755       if (target)
5756         return target;
5757       break;
5758
5759     CASE_FLT_FN (BUILT_IN_POWI):
5760       target = expand_builtin_powi (exp, target);
5761       if (target)
5762         return target;
5763       break;
5764
5765     CASE_FLT_FN (BUILT_IN_CEXPI):
5766       target = expand_builtin_cexpi (exp, target);
5767       gcc_assert (target);
5768       return target;
5769
5770     CASE_FLT_FN (BUILT_IN_SIN):
5771     CASE_FLT_FN (BUILT_IN_COS):
5772       if (! flag_unsafe_math_optimizations)
5773         break;
5774       target = expand_builtin_mathfn_3 (exp, target, subtarget);
5775       if (target)
5776         return target;
5777       break;
5778
5779     CASE_FLT_FN (BUILT_IN_SINCOS):
5780       if (! flag_unsafe_math_optimizations)
5781         break;
5782       target = expand_builtin_sincos (exp);
5783       if (target)
5784         return target;
5785       break;
5786
5787     case BUILT_IN_APPLY_ARGS:
5788       return expand_builtin_apply_args ();
5789
5790       /* __builtin_apply (FUNCTION, ARGUMENTS, ARGSIZE) invokes
5791          FUNCTION with a copy of the parameters described by
5792          ARGUMENTS, and ARGSIZE.  It returns a block of memory
5793          allocated on the stack into which is stored all the registers
5794          that might possibly be used for returning the result of a
5795          function.  ARGUMENTS is the value returned by
5796          __builtin_apply_args.  ARGSIZE is the number of bytes of
5797          arguments that must be copied.  ??? How should this value be
5798          computed?  We'll also need a safe worst case value for varargs
5799          functions.  */
5800     case BUILT_IN_APPLY:
5801       if (!validate_arglist (exp, POINTER_TYPE,
5802                              POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)
5803           && !validate_arglist (exp, REFERENCE_TYPE,
5804                                 POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
5805         return const0_rtx;
5806       else
5807         {
5808           rtx ops[3];
5809
5810           ops[0] = expand_normal (CALL_EXPR_ARG (exp, 0));
5811           ops[1] = expand_normal (CALL_EXPR_ARG (exp, 1));
5812           ops[2] = expand_normal (CALL_EXPR_ARG (exp, 2));
5813
5814           return expand_builtin_apply (ops[0], ops[1], ops[2]);
5815         }
5816
5817       /* __builtin_return (RESULT) causes the function to return the
5818          value described by RESULT.  RESULT is address of the block of
5819          memory returned by __builtin_apply.  */
5820     case BUILT_IN_RETURN:
5821       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
5822         expand_builtin_return (expand_normal (CALL_EXPR_ARG (exp, 0)));
5823       return const0_rtx;
5824
5825     case BUILT_IN_SAVEREGS:
5826       return expand_builtin_saveregs ();
5827
5828     case BUILT_IN_VA_ARG_PACK:
5829       /* All valid uses of __builtin_va_arg_pack () are removed during
5830          inlining.  */
5831       error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp);
5832       return const0_rtx;
5833
5834     case BUILT_IN_VA_ARG_PACK_LEN:
5835       /* All valid uses of __builtin_va_arg_pack_len () are removed during
5836          inlining.  */
5837       error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp);
5838       return const0_rtx;
5839
5840       /* Return the address of the first anonymous stack arg.  */
5841     case BUILT_IN_NEXT_ARG:
5842       if (fold_builtin_next_arg (exp, false))
5843         return const0_rtx;
5844       return expand_builtin_next_arg ();
5845
5846     case BUILT_IN_CLEAR_CACHE:
5847       target = expand_builtin___clear_cache (exp);
5848       if (target)
5849         return target;
5850       break;
5851
5852     case BUILT_IN_CLASSIFY_TYPE:
5853       return expand_builtin_classify_type (exp);
5854
5855     case BUILT_IN_CONSTANT_P:
5856       return const0_rtx;
5857
5858     case BUILT_IN_FRAME_ADDRESS:
5859     case BUILT_IN_RETURN_ADDRESS:
5860       return expand_builtin_frame_address (fndecl, exp);
5861
5862     /* Returns the address of the area where the structure is returned.
5863        0 otherwise.  */
5864     case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
5865       if (call_expr_nargs (exp) != 0
5866           || ! AGGREGATE_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))
5867           || !MEM_P (DECL_RTL (DECL_RESULT (current_function_decl))))
5868         return const0_rtx;
5869       else
5870         return XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
5871
5872     case BUILT_IN_ALLOCA:
5873     case BUILT_IN_ALLOCA_WITH_ALIGN:
5874       /* If the allocation stems from the declaration of a variable-sized
5875          object, it cannot accumulate.  */
5876       target = expand_builtin_alloca (exp, CALL_ALLOCA_FOR_VAR_P (exp));
5877       if (target)
5878         return target;
5879       break;
5880
5881     case BUILT_IN_STACK_SAVE:
5882       return expand_stack_save ();
5883
5884     case BUILT_IN_STACK_RESTORE:
5885       expand_stack_restore (CALL_EXPR_ARG (exp, 0));
5886       return const0_rtx;
5887
5888     case BUILT_IN_BSWAP16:
5889     case BUILT_IN_BSWAP32:
5890     case BUILT_IN_BSWAP64:
5891       target = expand_builtin_bswap (target_mode, exp, target, subtarget);
5892       if (target)
5893         return target;
5894       break;
5895
5896     CASE_INT_FN (BUILT_IN_FFS):
5897       target = expand_builtin_unop (target_mode, exp, target,
5898                                     subtarget, ffs_optab);
5899       if (target)
5900         return target;
5901       break;
5902
5903     CASE_INT_FN (BUILT_IN_CLZ):
5904       target = expand_builtin_unop (target_mode, exp, target,
5905                                     subtarget, clz_optab);
5906       if (target)
5907         return target;
5908       break;
5909
5910     CASE_INT_FN (BUILT_IN_CTZ):
5911       target = expand_builtin_unop (target_mode, exp, target,
5912                                     subtarget, ctz_optab);
5913       if (target)
5914         return target;
5915       break;
5916
5917     CASE_INT_FN (BUILT_IN_CLRSB):
5918       target = expand_builtin_unop (target_mode, exp, target,
5919                                     subtarget, clrsb_optab);
5920       if (target)
5921         return target;
5922       break;
5923
5924     CASE_INT_FN (BUILT_IN_POPCOUNT):
5925       target = expand_builtin_unop (target_mode, exp, target,
5926                                     subtarget, popcount_optab);
5927       if (target)
5928         return target;
5929       break;
5930
5931     CASE_INT_FN (BUILT_IN_PARITY):
5932       target = expand_builtin_unop (target_mode, exp, target,
5933                                     subtarget, parity_optab);
5934       if (target)
5935         return target;
5936       break;
5937
5938     case BUILT_IN_STRLEN:
5939       target = expand_builtin_strlen (exp, target, target_mode);
5940       if (target)
5941         return target;
5942       break;
5943
5944     case BUILT_IN_STRCPY:
5945       target = expand_builtin_strcpy (exp, target);
5946       if (target)
5947         return target;
5948       break;
5949
5950     case BUILT_IN_STRNCPY:
5951       target = expand_builtin_strncpy (exp, target);
5952       if (target)
5953         return target;
5954       break;
5955
5956     case BUILT_IN_STPCPY:
5957       target = expand_builtin_stpcpy (exp, target, mode);
5958       if (target)
5959         return target;
5960       break;
5961
5962     case BUILT_IN_MEMCPY:
5963       target = expand_builtin_memcpy (exp, target);
5964       if (target)
5965         return target;
5966       break;
5967
5968     case BUILT_IN_MEMPCPY:
5969       target = expand_builtin_mempcpy (exp, target, mode);
5970       if (target)
5971         return target;
5972       break;
5973
5974     case BUILT_IN_MEMSET:
5975       target = expand_builtin_memset (exp, target, mode);
5976       if (target)
5977         return target;
5978       break;
5979
5980     case BUILT_IN_BZERO:
5981       target = expand_builtin_bzero (exp);
5982       if (target)
5983         return target;
5984       break;
5985
5986     case BUILT_IN_STRCMP:
5987       target = expand_builtin_strcmp (exp, target);
5988       if (target)
5989         return target;
5990       break;
5991
5992     case BUILT_IN_STRNCMP:
5993       target = expand_builtin_strncmp (exp, target, mode);
5994       if (target)
5995         return target;
5996       break;
5997
5998     case BUILT_IN_BCMP:
5999     case BUILT_IN_MEMCMP:
6000       target = expand_builtin_memcmp (exp, target);
6001       if (target)
6002         return target;
6003       break;
6004
6005     case BUILT_IN_SETJMP:
6006       /* This should have been lowered to the builtins below.  */
6007       gcc_unreachable ();
6008
6009     case BUILT_IN_SETJMP_SETUP:
6010       /* __builtin_setjmp_setup is passed a pointer to an array of five words
6011           and the receiver label.  */
6012       if (validate_arglist (exp, POINTER_TYPE, POINTER_TYPE, VOID_TYPE))
6013         {
6014           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6015                                       VOIDmode, EXPAND_NORMAL);
6016           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 1), 0);
6017           rtx_insn *label_r = label_rtx (label);
6018
6019           /* This is copied from the handling of non-local gotos.  */
6020           expand_builtin_setjmp_setup (buf_addr, label_r);
6021           nonlocal_goto_handler_labels
6022             = gen_rtx_INSN_LIST (VOIDmode, label_r,
6023                                  nonlocal_goto_handler_labels);
6024           /* ??? Do not let expand_label treat us as such since we would
6025              not want to be both on the list of non-local labels and on
6026              the list of forced labels.  */
6027           FORCED_LABEL (label) = 0;
6028           return const0_rtx;
6029         }
6030       break;
6031
6032     case BUILT_IN_SETJMP_RECEIVER:
6033        /* __builtin_setjmp_receiver is passed the receiver label.  */
6034       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6035         {
6036           tree label = TREE_OPERAND (CALL_EXPR_ARG (exp, 0), 0);
6037           rtx_insn *label_r = label_rtx (label);
6038
6039           expand_builtin_setjmp_receiver (label_r);
6040           return const0_rtx;
6041         }
6042       break;
6043
6044       /* __builtin_longjmp is passed a pointer to an array of five words.
6045          It's similar to the C library longjmp function but works with
6046          __builtin_setjmp above.  */
6047     case BUILT_IN_LONGJMP:
6048       if (validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
6049         {
6050           rtx buf_addr = expand_expr (CALL_EXPR_ARG (exp, 0), subtarget,
6051                                       VOIDmode, EXPAND_NORMAL);
6052           rtx value = expand_normal (CALL_EXPR_ARG (exp, 1));
6053
6054           if (value != const1_rtx)
6055             {
6056               error ("%<__builtin_longjmp%> second argument must be 1");
6057               return const0_rtx;
6058             }
6059
6060           expand_builtin_longjmp (buf_addr, value);
6061           return const0_rtx;
6062         }
6063       break;
6064
6065     case BUILT_IN_NONLOCAL_GOTO:
6066       target = expand_builtin_nonlocal_goto (exp);
6067       if (target)
6068         return target;
6069       break;
6070
6071       /* This updates the setjmp buffer that is its argument with the value
6072          of the current stack pointer.  */
6073     case BUILT_IN_UPDATE_SETJMP_BUF:
6074       if (validate_arglist (exp, POINTER_TYPE, VOID_TYPE))
6075         {
6076           rtx buf_addr
6077             = expand_normal (CALL_EXPR_ARG (exp, 0));
6078
6079           expand_builtin_update_setjmp_buf (buf_addr);
6080           return const0_rtx;
6081         }
6082       break;
6083
6084     case BUILT_IN_TRAP:
6085       expand_builtin_trap ();
6086       return const0_rtx;
6087
6088     case BUILT_IN_UNREACHABLE:
6089       expand_builtin_unreachable ();
6090       return const0_rtx;
6091
6092     CASE_FLT_FN (BUILT_IN_SIGNBIT):
6093     case BUILT_IN_SIGNBITD32:
6094     case BUILT_IN_SIGNBITD64:
6095     case BUILT_IN_SIGNBITD128:
6096       target = expand_builtin_signbit (exp, target);
6097       if (target)
6098         return target;
6099       break;
6100
6101       /* Various hooks for the DWARF 2 __throw routine.  */
6102     case BUILT_IN_UNWIND_INIT:
6103       expand_builtin_unwind_init ();
6104       return const0_rtx;
6105     case BUILT_IN_DWARF_CFA:
6106       return virtual_cfa_rtx;
6107 #ifdef DWARF2_UNWIND_INFO
6108     case BUILT_IN_DWARF_SP_COLUMN:
6109       return expand_builtin_dwarf_sp_column ();
6110     case BUILT_IN_INIT_DWARF_REG_SIZES:
6111       expand_builtin_init_dwarf_reg_sizes (CALL_EXPR_ARG (exp, 0));
6112       return const0_rtx;
6113 #endif
6114     case BUILT_IN_FROB_RETURN_ADDR:
6115       return expand_builtin_frob_return_addr (CALL_EXPR_ARG (exp, 0));
6116     case BUILT_IN_EXTRACT_RETURN_ADDR:
6117       return expand_builtin_extract_return_addr (CALL_EXPR_ARG (exp, 0));
6118     case BUILT_IN_EH_RETURN:
6119       expand_builtin_eh_return (CALL_EXPR_ARG (exp, 0),
6120                                 CALL_EXPR_ARG (exp, 1));
6121       return const0_rtx;
6122     case BUILT_IN_EH_RETURN_DATA_REGNO:
6123       return expand_builtin_eh_return_data_regno (exp);
6124     case BUILT_IN_EXTEND_POINTER:
6125       return expand_builtin_extend_pointer (CALL_EXPR_ARG (exp, 0));
6126     case BUILT_IN_EH_POINTER:
6127       return expand_builtin_eh_pointer (exp);
6128     case BUILT_IN_EH_FILTER:
6129       return expand_builtin_eh_filter (exp);
6130     case BUILT_IN_EH_COPY_VALUES:
6131       return expand_builtin_eh_copy_values (exp);
6132
6133     case BUILT_IN_VA_START:
6134       return expand_builtin_va_start (exp);
6135     case BUILT_IN_VA_END:
6136       return expand_builtin_va_end (exp);
6137     case BUILT_IN_VA_COPY:
6138       return expand_builtin_va_copy (exp);
6139     case BUILT_IN_EXPECT:
6140       return expand_builtin_expect (exp, target);
6141     case BUILT_IN_ASSUME_ALIGNED:
6142       return expand_builtin_assume_aligned (exp, target);
6143     case BUILT_IN_PREFETCH:
6144       expand_builtin_prefetch (exp);
6145       return const0_rtx;
6146
6147     case BUILT_IN_INIT_TRAMPOLINE:
6148       return expand_builtin_init_trampoline (exp, true);
6149     case BUILT_IN_INIT_HEAP_TRAMPOLINE:
6150       return expand_builtin_init_trampoline (exp, false);
6151     case BUILT_IN_ADJUST_TRAMPOLINE:
6152       return expand_builtin_adjust_trampoline (exp);
6153
6154     case BUILT_IN_FORK:
6155     case BUILT_IN_EXECL:
6156     case BUILT_IN_EXECV:
6157     case BUILT_IN_EXECLP:
6158     case BUILT_IN_EXECLE:
6159     case BUILT_IN_EXECVP:
6160     case BUILT_IN_EXECVE:
6161       target = expand_builtin_fork_or_exec (fndecl, exp, target, ignore);
6162       if (target)
6163         return target;
6164       break;
6165
6166     case BUILT_IN_SYNC_FETCH_AND_ADD_1:
6167     case BUILT_IN_SYNC_FETCH_AND_ADD_2:
6168     case BUILT_IN_SYNC_FETCH_AND_ADD_4:
6169     case BUILT_IN_SYNC_FETCH_AND_ADD_8:
6170     case BUILT_IN_SYNC_FETCH_AND_ADD_16:
6171       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_ADD_1);
6172       target = expand_builtin_sync_operation (mode, exp, PLUS, false, target);
6173       if (target)
6174         return target;
6175       break;
6176
6177     case BUILT_IN_SYNC_FETCH_AND_SUB_1:
6178     case BUILT_IN_SYNC_FETCH_AND_SUB_2:
6179     case BUILT_IN_SYNC_FETCH_AND_SUB_4:
6180     case BUILT_IN_SYNC_FETCH_AND_SUB_8:
6181     case BUILT_IN_SYNC_FETCH_AND_SUB_16:
6182       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_SUB_1);
6183       target = expand_builtin_sync_operation (mode, exp, MINUS, false, target);
6184       if (target)
6185         return target;
6186       break;
6187
6188     case BUILT_IN_SYNC_FETCH_AND_OR_1:
6189     case BUILT_IN_SYNC_FETCH_AND_OR_2:
6190     case BUILT_IN_SYNC_FETCH_AND_OR_4:
6191     case BUILT_IN_SYNC_FETCH_AND_OR_8:
6192     case BUILT_IN_SYNC_FETCH_AND_OR_16:
6193       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_OR_1);
6194       target = expand_builtin_sync_operation (mode, exp, IOR, false, target);
6195       if (target)
6196         return target;
6197       break;
6198
6199     case BUILT_IN_SYNC_FETCH_AND_AND_1:
6200     case BUILT_IN_SYNC_FETCH_AND_AND_2:
6201     case BUILT_IN_SYNC_FETCH_AND_AND_4:
6202     case BUILT_IN_SYNC_FETCH_AND_AND_8:
6203     case BUILT_IN_SYNC_FETCH_AND_AND_16:
6204       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_AND_1);
6205       target = expand_builtin_sync_operation (mode, exp, AND, false, target);
6206       if (target)
6207         return target;
6208       break;
6209
6210     case BUILT_IN_SYNC_FETCH_AND_XOR_1:
6211     case BUILT_IN_SYNC_FETCH_AND_XOR_2:
6212     case BUILT_IN_SYNC_FETCH_AND_XOR_4:
6213     case BUILT_IN_SYNC_FETCH_AND_XOR_8:
6214     case BUILT_IN_SYNC_FETCH_AND_XOR_16:
6215       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_XOR_1);
6216       target = expand_builtin_sync_operation (mode, exp, XOR, false, target);
6217       if (target)
6218         return target;
6219       break;
6220
6221     case BUILT_IN_SYNC_FETCH_AND_NAND_1:
6222     case BUILT_IN_SYNC_FETCH_AND_NAND_2:
6223     case BUILT_IN_SYNC_FETCH_AND_NAND_4:
6224     case BUILT_IN_SYNC_FETCH_AND_NAND_8:
6225     case BUILT_IN_SYNC_FETCH_AND_NAND_16:
6226       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_FETCH_AND_NAND_1);
6227       target = expand_builtin_sync_operation (mode, exp, NOT, false, target);
6228       if (target)
6229         return target;
6230       break;
6231
6232     case BUILT_IN_SYNC_ADD_AND_FETCH_1:
6233     case BUILT_IN_SYNC_ADD_AND_FETCH_2:
6234     case BUILT_IN_SYNC_ADD_AND_FETCH_4:
6235     case BUILT_IN_SYNC_ADD_AND_FETCH_8:
6236     case BUILT_IN_SYNC_ADD_AND_FETCH_16:
6237       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_ADD_AND_FETCH_1);
6238       target = expand_builtin_sync_operation (mode, exp, PLUS, true, target);
6239       if (target)
6240         return target;
6241       break;
6242
6243     case BUILT_IN_SYNC_SUB_AND_FETCH_1:
6244     case BUILT_IN_SYNC_SUB_AND_FETCH_2:
6245     case BUILT_IN_SYNC_SUB_AND_FETCH_4:
6246     case BUILT_IN_SYNC_SUB_AND_FETCH_8:
6247     case BUILT_IN_SYNC_SUB_AND_FETCH_16:
6248       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_SUB_AND_FETCH_1);
6249       target = expand_builtin_sync_operation (mode, exp, MINUS, true, target);
6250       if (target)
6251         return target;
6252       break;
6253
6254     case BUILT_IN_SYNC_OR_AND_FETCH_1:
6255     case BUILT_IN_SYNC_OR_AND_FETCH_2:
6256     case BUILT_IN_SYNC_OR_AND_FETCH_4:
6257     case BUILT_IN_SYNC_OR_AND_FETCH_8:
6258     case BUILT_IN_SYNC_OR_AND_FETCH_16:
6259       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_OR_AND_FETCH_1);
6260       target = expand_builtin_sync_operation (mode, exp, IOR, true, target);
6261       if (target)
6262         return target;
6263       break;
6264
6265     case BUILT_IN_SYNC_AND_AND_FETCH_1:
6266     case BUILT_IN_SYNC_AND_AND_FETCH_2:
6267     case BUILT_IN_SYNC_AND_AND_FETCH_4:
6268     case BUILT_IN_SYNC_AND_AND_FETCH_8:
6269     case BUILT_IN_SYNC_AND_AND_FETCH_16:
6270       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_AND_AND_FETCH_1);
6271       target = expand_builtin_sync_operation (mode, exp, AND, true, target);
6272       if (target)
6273         return target;
6274       break;
6275
6276     case BUILT_IN_SYNC_XOR_AND_FETCH_1:
6277     case BUILT_IN_SYNC_XOR_AND_FETCH_2:
6278     case BUILT_IN_SYNC_XOR_AND_FETCH_4:
6279     case BUILT_IN_SYNC_XOR_AND_FETCH_8:
6280     case BUILT_IN_SYNC_XOR_AND_FETCH_16:
6281       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_XOR_AND_FETCH_1);
6282       target = expand_builtin_sync_operation (mode, exp, XOR, true, target);
6283       if (target)
6284         return target;
6285       break;
6286
6287     case BUILT_IN_SYNC_NAND_AND_FETCH_1:
6288     case BUILT_IN_SYNC_NAND_AND_FETCH_2:
6289     case BUILT_IN_SYNC_NAND_AND_FETCH_4:
6290     case BUILT_IN_SYNC_NAND_AND_FETCH_8:
6291     case BUILT_IN_SYNC_NAND_AND_FETCH_16:
6292       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_NAND_AND_FETCH_1);
6293       target = expand_builtin_sync_operation (mode, exp, NOT, true, target);
6294       if (target)
6295         return target;
6296       break;
6297
6298     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1:
6299     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_2:
6300     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_4:
6301     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_8:
6302     case BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_16:
6303       if (mode == VOIDmode)
6304         mode = TYPE_MODE (boolean_type_node);
6305       if (!target || !register_operand (target, mode))
6306         target = gen_reg_rtx (mode);
6307
6308       mode = get_builtin_sync_mode
6309                                 (fcode - BUILT_IN_SYNC_BOOL_COMPARE_AND_SWAP_1);
6310       target = expand_builtin_compare_and_swap (mode, exp, true, target);
6311       if (target)
6312         return target;
6313       break;
6314
6315     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1:
6316     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_2:
6317     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_4:
6318     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_8:
6319     case BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_16:
6320       mode = get_builtin_sync_mode
6321                                 (fcode - BUILT_IN_SYNC_VAL_COMPARE_AND_SWAP_1);
6322       target = expand_builtin_compare_and_swap (mode, exp, false, target);
6323       if (target)
6324         return target;
6325       break;
6326
6327     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_1:
6328     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_2:
6329     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_4:
6330     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_8:
6331     case BUILT_IN_SYNC_LOCK_TEST_AND_SET_16:
6332       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_TEST_AND_SET_1);
6333       target = expand_builtin_sync_lock_test_and_set (mode, exp, target);
6334       if (target)
6335         return target;
6336       break;
6337
6338     case BUILT_IN_SYNC_LOCK_RELEASE_1:
6339     case BUILT_IN_SYNC_LOCK_RELEASE_2:
6340     case BUILT_IN_SYNC_LOCK_RELEASE_4:
6341     case BUILT_IN_SYNC_LOCK_RELEASE_8:
6342     case BUILT_IN_SYNC_LOCK_RELEASE_16:
6343       mode = get_builtin_sync_mode (fcode - BUILT_IN_SYNC_LOCK_RELEASE_1);
6344       expand_builtin_sync_lock_release (mode, exp);
6345       return const0_rtx;
6346
6347     case BUILT_IN_SYNC_SYNCHRONIZE:
6348       expand_builtin_sync_synchronize ();
6349       return const0_rtx;
6350
6351     case BUILT_IN_ATOMIC_EXCHANGE_1:
6352     case BUILT_IN_ATOMIC_EXCHANGE_2:
6353     case BUILT_IN_ATOMIC_EXCHANGE_4:
6354     case BUILT_IN_ATOMIC_EXCHANGE_8:
6355     case BUILT_IN_ATOMIC_EXCHANGE_16:
6356       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_EXCHANGE_1);
6357       target = expand_builtin_atomic_exchange (mode, exp, target);
6358       if (target)
6359         return target;
6360       break;
6361
6362     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1:
6363     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_2:
6364     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_4:
6365     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_8:
6366     case BUILT_IN_ATOMIC_COMPARE_EXCHANGE_16:
6367       {
6368         unsigned int nargs, z;
6369         vec<tree, va_gc> *vec;
6370
6371         mode =
6372             get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_COMPARE_EXCHANGE_1);
6373         target = expand_builtin_atomic_compare_exchange (mode, exp, target);
6374         if (target)
6375           return target;
6376
6377         /* If this is turned into an external library call, the weak parameter
6378            must be dropped to match the expected parameter list.  */
6379         nargs = call_expr_nargs (exp);
6380         vec_alloc (vec, nargs - 1);
6381         for (z = 0; z < 3; z++)
6382           vec->quick_push (CALL_EXPR_ARG (exp, z));
6383         /* Skip the boolean weak parameter.  */
6384         for (z = 4; z < 6; z++)
6385           vec->quick_push (CALL_EXPR_ARG (exp, z));
6386         exp = build_call_vec (TREE_TYPE (exp), CALL_EXPR_FN (exp), vec);
6387         break;
6388       }
6389
6390     case BUILT_IN_ATOMIC_LOAD_1:
6391     case BUILT_IN_ATOMIC_LOAD_2:
6392     case BUILT_IN_ATOMIC_LOAD_4:
6393     case BUILT_IN_ATOMIC_LOAD_8:
6394     case BUILT_IN_ATOMIC_LOAD_16:
6395       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_LOAD_1);
6396       target = expand_builtin_atomic_load (mode, exp, target);
6397       if (target)
6398         return target;
6399       break;
6400
6401     case BUILT_IN_ATOMIC_STORE_1:
6402     case BUILT_IN_ATOMIC_STORE_2:
6403     case BUILT_IN_ATOMIC_STORE_4:
6404     case BUILT_IN_ATOMIC_STORE_8:
6405     case BUILT_IN_ATOMIC_STORE_16:
6406       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_STORE_1);
6407       target = expand_builtin_atomic_store (mode, exp);
6408       if (target)
6409         return const0_rtx;
6410       break;
6411
6412     case BUILT_IN_ATOMIC_ADD_FETCH_1:
6413     case BUILT_IN_ATOMIC_ADD_FETCH_2:
6414     case BUILT_IN_ATOMIC_ADD_FETCH_4:
6415     case BUILT_IN_ATOMIC_ADD_FETCH_8:
6416     case BUILT_IN_ATOMIC_ADD_FETCH_16:
6417       {
6418         enum built_in_function lib;
6419         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1);
6420         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_ADD_1 +
6421                                        (fcode - BUILT_IN_ATOMIC_ADD_FETCH_1));
6422         target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, true,
6423                                                  ignore, lib);
6424         if (target)
6425           return target;
6426         break;
6427       }
6428     case BUILT_IN_ATOMIC_SUB_FETCH_1:
6429     case BUILT_IN_ATOMIC_SUB_FETCH_2:
6430     case BUILT_IN_ATOMIC_SUB_FETCH_4:
6431     case BUILT_IN_ATOMIC_SUB_FETCH_8:
6432     case BUILT_IN_ATOMIC_SUB_FETCH_16:
6433       {
6434         enum built_in_function lib;
6435         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1);
6436         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_SUB_1 +
6437                                        (fcode - BUILT_IN_ATOMIC_SUB_FETCH_1));
6438         target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, true,
6439                                                  ignore, lib);
6440         if (target)
6441           return target;
6442         break;
6443       }
6444     case BUILT_IN_ATOMIC_AND_FETCH_1:
6445     case BUILT_IN_ATOMIC_AND_FETCH_2:
6446     case BUILT_IN_ATOMIC_AND_FETCH_4:
6447     case BUILT_IN_ATOMIC_AND_FETCH_8:
6448     case BUILT_IN_ATOMIC_AND_FETCH_16:
6449       {
6450         enum built_in_function lib;
6451         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_AND_FETCH_1);
6452         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_AND_1 +
6453                                        (fcode - BUILT_IN_ATOMIC_AND_FETCH_1));
6454         target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, true,
6455                                                  ignore, lib);
6456         if (target)
6457           return target;
6458         break;
6459       }
6460     case BUILT_IN_ATOMIC_NAND_FETCH_1:
6461     case BUILT_IN_ATOMIC_NAND_FETCH_2:
6462     case BUILT_IN_ATOMIC_NAND_FETCH_4:
6463     case BUILT_IN_ATOMIC_NAND_FETCH_8:
6464     case BUILT_IN_ATOMIC_NAND_FETCH_16:
6465       {
6466         enum built_in_function lib;
6467         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1);
6468         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_NAND_1 +
6469                                        (fcode - BUILT_IN_ATOMIC_NAND_FETCH_1));
6470         target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, true,
6471                                                  ignore, lib);
6472         if (target)
6473           return target;
6474         break;
6475       }
6476     case BUILT_IN_ATOMIC_XOR_FETCH_1:
6477     case BUILT_IN_ATOMIC_XOR_FETCH_2:
6478     case BUILT_IN_ATOMIC_XOR_FETCH_4:
6479     case BUILT_IN_ATOMIC_XOR_FETCH_8:
6480     case BUILT_IN_ATOMIC_XOR_FETCH_16:
6481       {
6482         enum built_in_function lib;
6483         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1);
6484         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_XOR_1 +
6485                                        (fcode - BUILT_IN_ATOMIC_XOR_FETCH_1));
6486         target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, true,
6487                                                  ignore, lib);
6488         if (target)
6489           return target;
6490         break;
6491       }
6492     case BUILT_IN_ATOMIC_OR_FETCH_1:
6493     case BUILT_IN_ATOMIC_OR_FETCH_2:
6494     case BUILT_IN_ATOMIC_OR_FETCH_4:
6495     case BUILT_IN_ATOMIC_OR_FETCH_8:
6496     case BUILT_IN_ATOMIC_OR_FETCH_16:
6497       {
6498         enum built_in_function lib;
6499         mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_OR_FETCH_1);
6500         lib = (enum built_in_function)((int)BUILT_IN_ATOMIC_FETCH_OR_1 +
6501                                        (fcode - BUILT_IN_ATOMIC_OR_FETCH_1));
6502         target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, true,
6503                                                  ignore, lib);
6504         if (target)
6505           return target;
6506         break;
6507       }
6508     case BUILT_IN_ATOMIC_FETCH_ADD_1:
6509     case BUILT_IN_ATOMIC_FETCH_ADD_2:
6510     case BUILT_IN_ATOMIC_FETCH_ADD_4:
6511     case BUILT_IN_ATOMIC_FETCH_ADD_8:
6512     case BUILT_IN_ATOMIC_FETCH_ADD_16:
6513       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_ADD_1);
6514       target = expand_builtin_atomic_fetch_op (mode, exp, target, PLUS, false,
6515                                                ignore, BUILT_IN_NONE);
6516       if (target)
6517         return target;
6518       break;
6519
6520     case BUILT_IN_ATOMIC_FETCH_SUB_1:
6521     case BUILT_IN_ATOMIC_FETCH_SUB_2:
6522     case BUILT_IN_ATOMIC_FETCH_SUB_4:
6523     case BUILT_IN_ATOMIC_FETCH_SUB_8:
6524     case BUILT_IN_ATOMIC_FETCH_SUB_16:
6525       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_SUB_1);
6526       target = expand_builtin_atomic_fetch_op (mode, exp, target, MINUS, false,
6527                                                ignore, BUILT_IN_NONE);
6528       if (target)
6529         return target;
6530       break;
6531
6532     case BUILT_IN_ATOMIC_FETCH_AND_1:
6533     case BUILT_IN_ATOMIC_FETCH_AND_2:
6534     case BUILT_IN_ATOMIC_FETCH_AND_4:
6535     case BUILT_IN_ATOMIC_FETCH_AND_8:
6536     case BUILT_IN_ATOMIC_FETCH_AND_16:
6537       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_AND_1);
6538       target = expand_builtin_atomic_fetch_op (mode, exp, target, AND, false,
6539                                                ignore, BUILT_IN_NONE);
6540       if (target)
6541         return target;
6542       break;
6543
6544     case BUILT_IN_ATOMIC_FETCH_NAND_1:
6545     case BUILT_IN_ATOMIC_FETCH_NAND_2:
6546     case BUILT_IN_ATOMIC_FETCH_NAND_4:
6547     case BUILT_IN_ATOMIC_FETCH_NAND_8:
6548     case BUILT_IN_ATOMIC_FETCH_NAND_16:
6549       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_NAND_1);
6550       target = expand_builtin_atomic_fetch_op (mode, exp, target, NOT, false,
6551                                                ignore, BUILT_IN_NONE);
6552       if (target)
6553         return target;
6554       break;
6555
6556     case BUILT_IN_ATOMIC_FETCH_XOR_1:
6557     case BUILT_IN_ATOMIC_FETCH_XOR_2:
6558     case BUILT_IN_ATOMIC_FETCH_XOR_4:
6559     case BUILT_IN_ATOMIC_FETCH_XOR_8:
6560     case BUILT_IN_ATOMIC_FETCH_XOR_16:
6561       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_XOR_1);
6562       target = expand_builtin_atomic_fetch_op (mode, exp, target, XOR, false,
6563                                                ignore, BUILT_IN_NONE);
6564       if (target)
6565         return target;
6566       break;
6567
6568     case BUILT_IN_ATOMIC_FETCH_OR_1:
6569     case BUILT_IN_ATOMIC_FETCH_OR_2:
6570     case BUILT_IN_ATOMIC_FETCH_OR_4:
6571     case BUILT_IN_ATOMIC_FETCH_OR_8:
6572     case BUILT_IN_ATOMIC_FETCH_OR_16:
6573       mode = get_builtin_sync_mode (fcode - BUILT_IN_ATOMIC_FETCH_OR_1);
6574       target = expand_builtin_atomic_fetch_op (mode, exp, target, IOR, false,
6575                                                ignore, BUILT_IN_NONE);
6576       if (target)
6577         return target;
6578       break;
6579
6580     case BUILT_IN_ATOMIC_TEST_AND_SET:
6581       return expand_builtin_atomic_test_and_set (exp, target);
6582
6583     case BUILT_IN_ATOMIC_CLEAR:
6584       return expand_builtin_atomic_clear (exp);
6585
6586     case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
6587       return expand_builtin_atomic_always_lock_free (exp);
6588
6589     case BUILT_IN_ATOMIC_IS_LOCK_FREE:
6590       target = expand_builtin_atomic_is_lock_free (exp);
6591       if (target)
6592         return target;
6593       break;
6594
6595     case BUILT_IN_ATOMIC_THREAD_FENCE:
6596       expand_builtin_atomic_thread_fence (exp);
6597       return const0_rtx;
6598
6599     case BUILT_IN_ATOMIC_SIGNAL_FENCE:
6600       expand_builtin_atomic_signal_fence (exp);
6601       return const0_rtx;
6602
6603     case BUILT_IN_OBJECT_SIZE:
6604       return expand_builtin_object_size (exp);
6605
6606     case BUILT_IN_MEMCPY_CHK:
6607     case BUILT_IN_MEMPCPY_CHK:
6608     case BUILT_IN_MEMMOVE_CHK:
6609     case BUILT_IN_MEMSET_CHK:
6610       target = expand_builtin_memory_chk (exp, target, mode, fcode);
6611       if (target)
6612         return target;
6613       break;
6614
6615     case BUILT_IN_STRCPY_CHK:
6616     case BUILT_IN_STPCPY_CHK:
6617     case BUILT_IN_STRNCPY_CHK:
6618     case BUILT_IN_STPNCPY_CHK:
6619     case BUILT_IN_STRCAT_CHK:
6620     case BUILT_IN_STRNCAT_CHK:
6621     case BUILT_IN_SNPRINTF_CHK:
6622     case BUILT_IN_VSNPRINTF_CHK:
6623       maybe_emit_chk_warning (exp, fcode);
6624       break;
6625
6626     case BUILT_IN_SPRINTF_CHK:
6627     case BUILT_IN_VSPRINTF_CHK:
6628       maybe_emit_sprintf_chk_warning (exp, fcode);
6629       break;
6630
6631     case BUILT_IN_FREE:
6632       if (warn_free_nonheap_object)
6633         maybe_emit_free_warning (exp);
6634       break;
6635
6636     case BUILT_IN_THREAD_POINTER:
6637       return expand_builtin_thread_pointer (exp, target);
6638
6639     case BUILT_IN_SET_THREAD_POINTER:
6640       expand_builtin_set_thread_pointer (exp);
6641       return const0_rtx;
6642
6643     case BUILT_IN_CILK_DETACH:
6644       expand_builtin_cilk_detach (exp);
6645       return const0_rtx;
6646
6647     case BUILT_IN_CILK_POP_FRAME:
6648       expand_builtin_cilk_pop_frame (exp);
6649       return const0_rtx;
6650
6651     case BUILT_IN_CHKP_INIT_PTR_BOUNDS:
6652     case BUILT_IN_CHKP_NULL_PTR_BOUNDS:
6653     case BUILT_IN_CHKP_COPY_PTR_BOUNDS:
6654     case BUILT_IN_CHKP_CHECK_PTR_LBOUNDS:
6655     case BUILT_IN_CHKP_CHECK_PTR_UBOUNDS:
6656     case BUILT_IN_CHKP_CHECK_PTR_BOUNDS:
6657     case BUILT_IN_CHKP_SET_PTR_BOUNDS:
6658     case BUILT_IN_CHKP_NARROW_PTR_BOUNDS:
6659     case BUILT_IN_CHKP_STORE_PTR_BOUNDS:
6660     case BUILT_IN_CHKP_GET_PTR_LBOUND:
6661     case BUILT_IN_CHKP_GET_PTR_UBOUND:
6662       /* We allow user CHKP builtins if Pointer Bounds
6663          Checker is off.  */
6664       if (!chkp_function_instrumented_p (current_function_decl))
6665         {
6666           if (fcode == BUILT_IN_CHKP_SET_PTR_BOUNDS
6667               || fcode == BUILT_IN_CHKP_NARROW_PTR_BOUNDS
6668               || fcode == BUILT_IN_CHKP_INIT_PTR_BOUNDS
6669               || fcode == BUILT_IN_CHKP_NULL_PTR_BOUNDS
6670               || fcode == BUILT_IN_CHKP_COPY_PTR_BOUNDS)
6671             return expand_normal (CALL_EXPR_ARG (exp, 0));
6672           else if (fcode == BUILT_IN_CHKP_GET_PTR_LBOUND)
6673             return expand_normal (size_zero_node);
6674           else if (fcode == BUILT_IN_CHKP_GET_PTR_UBOUND)
6675             return expand_normal (size_int (-1));
6676           else
6677             return const0_rtx;
6678         }
6679       /* FALLTHROUGH */
6680
6681     case BUILT_IN_CHKP_BNDMK:
6682     case BUILT_IN_CHKP_BNDSTX:
6683     case BUILT_IN_CHKP_BNDCL:
6684     case BUILT_IN_CHKP_BNDCU:
6685     case BUILT_IN_CHKP_BNDLDX:
6686     case BUILT_IN_CHKP_BNDRET:
6687     case BUILT_IN_CHKP_INTERSECT:
6688     case BUILT_IN_CHKP_NARROW:
6689     case BUILT_IN_CHKP_EXTRACT_LOWER:
6690     case BUILT_IN_CHKP_EXTRACT_UPPER:
6691       /* Software implementation of Pointer Bounds Checker is NYI.
6692          Target support is required.  */
6693       error ("Your target platform does not support -fcheck-pointer-bounds");
6694       break;
6695
6696     case BUILT_IN_ACC_ON_DEVICE:
6697       /* Do library call, if we failed to expand the builtin when
6698          folding.  */
6699       break;
6700
6701     default:    /* just do library call, if unknown builtin */
6702       break;
6703     }
6704
6705   /* The switch statement above can drop through to cause the function
6706      to be called normally.  */
6707   return expand_call (exp, target, ignore);
6708 }
6709
6710 /* Similar to expand_builtin but is used for instrumented calls.  */
6711
6712 rtx
6713 expand_builtin_with_bounds (tree exp, rtx target,
6714                             rtx subtarget ATTRIBUTE_UNUSED,
6715                             machine_mode mode, int ignore)
6716 {
6717   tree fndecl = get_callee_fndecl (exp);
6718   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
6719
6720   gcc_assert (CALL_WITH_BOUNDS_P (exp));
6721
6722   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6723     return targetm.expand_builtin (exp, target, subtarget, mode, ignore);
6724
6725   gcc_assert (fcode > BEGIN_CHKP_BUILTINS
6726               && fcode < END_CHKP_BUILTINS);
6727
6728   switch (fcode)
6729     {
6730     case BUILT_IN_CHKP_MEMCPY_NOBND_NOCHK_CHKP:
6731       target = expand_builtin_memcpy_with_bounds (exp, target);
6732       if (target)
6733         return target;
6734       break;
6735
6736     case BUILT_IN_CHKP_MEMPCPY_NOBND_NOCHK_CHKP:
6737       target = expand_builtin_mempcpy_with_bounds (exp, target, mode);
6738       if (target)
6739         return target;
6740       break;
6741
6742     case BUILT_IN_CHKP_MEMSET_NOBND_NOCHK_CHKP:
6743       target = expand_builtin_memset_with_bounds (exp, target, mode);
6744       if (target)
6745         return target;
6746       break;
6747
6748     default:
6749       break;
6750     }
6751
6752   /* The switch statement above can drop through to cause the function
6753      to be called normally.  */
6754   return expand_call (exp, target, ignore);
6755  }
6756
6757 /* Determine whether a tree node represents a call to a built-in
6758    function.  If the tree T is a call to a built-in function with
6759    the right number of arguments of the appropriate types, return
6760    the DECL_FUNCTION_CODE of the call, e.g. BUILT_IN_SQRT.
6761    Otherwise the return value is END_BUILTINS.  */
6762
6763 enum built_in_function
6764 builtin_mathfn_code (const_tree t)
6765 {
6766   const_tree fndecl, arg, parmlist;
6767   const_tree argtype, parmtype;
6768   const_call_expr_arg_iterator iter;
6769
6770   if (TREE_CODE (t) != CALL_EXPR
6771       || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6772     return END_BUILTINS;
6773
6774   fndecl = get_callee_fndecl (t);
6775   if (fndecl == NULL_TREE
6776       || TREE_CODE (fndecl) != FUNCTION_DECL
6777       || ! DECL_BUILT_IN (fndecl)
6778       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6779     return END_BUILTINS;
6780
6781   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6782   init_const_call_expr_arg_iterator (t, &iter);
6783   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6784     {
6785       /* If a function doesn't take a variable number of arguments,
6786          the last element in the list will have type `void'.  */
6787       parmtype = TREE_VALUE (parmlist);
6788       if (VOID_TYPE_P (parmtype))
6789         {
6790           if (more_const_call_expr_args_p (&iter))
6791             return END_BUILTINS;
6792           return DECL_FUNCTION_CODE (fndecl);
6793         }
6794
6795       if (! more_const_call_expr_args_p (&iter))
6796         return END_BUILTINS;
6797
6798       arg = next_const_call_expr_arg (&iter);
6799       argtype = TREE_TYPE (arg);
6800
6801       if (SCALAR_FLOAT_TYPE_P (parmtype))
6802         {
6803           if (! SCALAR_FLOAT_TYPE_P (argtype))
6804             return END_BUILTINS;
6805         }
6806       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6807         {
6808           if (! COMPLEX_FLOAT_TYPE_P (argtype))
6809             return END_BUILTINS;
6810         }
6811       else if (POINTER_TYPE_P (parmtype))
6812         {
6813           if (! POINTER_TYPE_P (argtype))
6814             return END_BUILTINS;
6815         }
6816       else if (INTEGRAL_TYPE_P (parmtype))
6817         {
6818           if (! INTEGRAL_TYPE_P (argtype))
6819             return END_BUILTINS;
6820         }
6821       else
6822         return END_BUILTINS;
6823     }
6824
6825   /* Variable-length argument list.  */
6826   return DECL_FUNCTION_CODE (fndecl);
6827 }
6828
6829 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6830    evaluate to a constant.  */
6831
6832 static tree
6833 fold_builtin_constant_p (tree arg)
6834 {
6835   /* We return 1 for a numeric type that's known to be a constant
6836      value at compile-time or for an aggregate type that's a
6837      literal constant.  */
6838   STRIP_NOPS (arg);
6839
6840   /* If we know this is a constant, emit the constant of one.  */
6841   if (CONSTANT_CLASS_P (arg)
6842       || (TREE_CODE (arg) == CONSTRUCTOR
6843           && TREE_CONSTANT (arg)))
6844     return integer_one_node;
6845   if (TREE_CODE (arg) == ADDR_EXPR)
6846     {
6847        tree op = TREE_OPERAND (arg, 0);
6848        if (TREE_CODE (op) == STRING_CST
6849            || (TREE_CODE (op) == ARRAY_REF
6850                && integer_zerop (TREE_OPERAND (op, 1))
6851                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6852          return integer_one_node;
6853     }
6854
6855   /* If this expression has side effects, show we don't know it to be a
6856      constant.  Likewise if it's a pointer or aggregate type since in
6857      those case we only want literals, since those are only optimized
6858      when generating RTL, not later.
6859      And finally, if we are compiling an initializer, not code, we
6860      need to return a definite result now; there's not going to be any
6861      more optimization done.  */
6862   if (TREE_SIDE_EFFECTS (arg)
6863       || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6864       || POINTER_TYPE_P (TREE_TYPE (arg))
6865       || cfun == 0
6866       || folding_initializer
6867       || force_folding_builtin_constant_p)
6868     return integer_zero_node;
6869
6870   return NULL_TREE;
6871 }
6872
6873 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6874    return it as a truthvalue.  */
6875
6876 static tree
6877 build_builtin_expect_predicate (location_t loc, tree pred, tree expected,
6878                                 tree predictor)
6879 {
6880   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6881
6882   fn = builtin_decl_explicit (BUILT_IN_EXPECT);
6883   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6884   ret_type = TREE_TYPE (TREE_TYPE (fn));
6885   pred_type = TREE_VALUE (arg_types);
6886   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6887
6888   pred = fold_convert_loc (loc, pred_type, pred);
6889   expected = fold_convert_loc (loc, expected_type, expected);
6890   call_expr = build_call_expr_loc (loc, fn, predictor ? 3 : 2, pred, expected,
6891                                    predictor);
6892
6893   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6894                  build_int_cst (ret_type, 0));
6895 }
6896
6897 /* Fold a call to builtin_expect with arguments ARG0 and ARG1.  Return
6898    NULL_TREE if no simplification is possible.  */
6899
6900 tree
6901 fold_builtin_expect (location_t loc, tree arg0, tree arg1, tree arg2)
6902 {
6903   tree inner, fndecl, inner_arg0;
6904   enum tree_code code;
6905
6906   /* Distribute the expected value over short-circuiting operators.
6907      See through the cast from truthvalue_type_node to long.  */
6908   inner_arg0 = arg0;
6909   while (CONVERT_EXPR_P (inner_arg0)
6910          && INTEGRAL_TYPE_P (TREE_TYPE (inner_arg0))
6911          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner_arg0, 0))))
6912     inner_arg0 = TREE_OPERAND (inner_arg0, 0);
6913
6914   /* If this is a builtin_expect within a builtin_expect keep the
6915      inner one.  See through a comparison against a constant.  It
6916      might have been added to create a thruthvalue.  */
6917   inner = inner_arg0;
6918
6919   if (COMPARISON_CLASS_P (inner)
6920       && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6921     inner = TREE_OPERAND (inner, 0);
6922
6923   if (TREE_CODE (inner) == CALL_EXPR
6924       && (fndecl = get_callee_fndecl (inner))
6925       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6926       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6927     return arg0;
6928
6929   inner = inner_arg0;
6930   code = TREE_CODE (inner);
6931   if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6932     {
6933       tree op0 = TREE_OPERAND (inner, 0);
6934       tree op1 = TREE_OPERAND (inner, 1);
6935
6936       op0 = build_builtin_expect_predicate (loc, op0, arg1, arg2);
6937       op1 = build_builtin_expect_predicate (loc, op1, arg1, arg2);
6938       inner = build2 (code, TREE_TYPE (inner), op0, op1);
6939
6940       return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6941     }
6942
6943   /* If the argument isn't invariant then there's nothing else we can do.  */
6944   if (!TREE_CONSTANT (inner_arg0))
6945     return NULL_TREE;
6946
6947   /* If we expect that a comparison against the argument will fold to
6948      a constant return the constant.  In practice, this means a true
6949      constant or the address of a non-weak symbol.  */
6950   inner = inner_arg0;
6951   STRIP_NOPS (inner);
6952   if (TREE_CODE (inner) == ADDR_EXPR)
6953     {
6954       do
6955         {
6956           inner = TREE_OPERAND (inner, 0);
6957         }
6958       while (TREE_CODE (inner) == COMPONENT_REF
6959              || TREE_CODE (inner) == ARRAY_REF);
6960       if ((TREE_CODE (inner) == VAR_DECL
6961            || TREE_CODE (inner) == FUNCTION_DECL)
6962           && DECL_WEAK (inner))
6963         return NULL_TREE;
6964     }
6965
6966   /* Otherwise, ARG0 already has the proper type for the return value.  */
6967   return arg0;
6968 }
6969
6970 /* Fold a call to __builtin_classify_type with argument ARG.  */
6971
6972 static tree
6973 fold_builtin_classify_type (tree arg)
6974 {
6975   if (arg == 0)
6976     return build_int_cst (integer_type_node, no_type_class);
6977
6978   return build_int_cst (integer_type_node, type_to_class (TREE_TYPE (arg)));
6979 }
6980
6981 /* Fold a call to __builtin_strlen with argument ARG.  */
6982
6983 static tree
6984 fold_builtin_strlen (location_t loc, tree type, tree arg)
6985 {
6986   if (!validate_arg (arg, POINTER_TYPE))
6987     return NULL_TREE;
6988   else
6989     {
6990       tree len = c_strlen (arg, 0);
6991
6992       if (len)
6993         return fold_convert_loc (loc, type, len);
6994
6995       return NULL_TREE;
6996     }
6997 }
6998
6999 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
7000
7001 static tree
7002 fold_builtin_inf (location_t loc, tree type, int warn)
7003 {
7004   REAL_VALUE_TYPE real;
7005
7006   /* __builtin_inff is intended to be usable to define INFINITY on all
7007      targets.  If an infinity is not available, INFINITY expands "to a
7008      positive constant of type float that overflows at translation
7009      time", footnote "In this case, using INFINITY will violate the
7010      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
7011      Thus we pedwarn to ensure this constraint violation is
7012      diagnosed.  */
7013   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
7014     pedwarn (loc, 0, "target format does not support infinity");
7015
7016   real_inf (&real);
7017   return build_real (type, real);
7018 }
7019
7020 /* Fold function call to builtin sincos, sincosf, or sincosl.  Return
7021    NULL_TREE if no simplification can be made.  */
7022
7023 static tree
7024 fold_builtin_sincos (location_t loc,
7025                      tree arg0, tree arg1, tree arg2)
7026 {
7027   tree type;
7028   tree fndecl, call = NULL_TREE;
7029
7030   if (!validate_arg (arg0, REAL_TYPE)
7031       || !validate_arg (arg1, POINTER_TYPE)
7032       || !validate_arg (arg2, POINTER_TYPE))
7033     return NULL_TREE;
7034
7035   type = TREE_TYPE (arg0);
7036
7037   /* Calculate the result when the argument is a constant.  */
7038   built_in_function fn = mathfn_built_in_2 (type, CFN_BUILT_IN_CEXPI);
7039   if (fn == END_BUILTINS)
7040     return NULL_TREE;
7041
7042   /* Canonicalize sincos to cexpi.  */
7043   if (TREE_CODE (arg0) == REAL_CST)
7044     {
7045       tree complex_type = build_complex_type (type);
7046       call = fold_const_call (as_combined_fn (fn), complex_type, arg0);
7047     }
7048   if (!call)
7049     {
7050       if (!targetm.libc_has_function (function_c99_math_complex)
7051           || !builtin_decl_implicit_p (fn))
7052         return NULL_TREE;
7053       fndecl = builtin_decl_explicit (fn);
7054       call = build_call_expr_loc (loc, fndecl, 1, arg0);
7055       call = builtin_save_expr (call);
7056     }
7057
7058   return build2 (COMPOUND_EXPR, void_type_node,
7059                  build2 (MODIFY_EXPR, void_type_node,
7060                          build_fold_indirect_ref_loc (loc, arg1),
7061                          fold_build1_loc (loc, IMAGPART_EXPR, type, call)),
7062                  build2 (MODIFY_EXPR, void_type_node,
7063                          build_fold_indirect_ref_loc (loc, arg2),
7064                          fold_build1_loc (loc, REALPART_EXPR, type, call)));
7065 }
7066
7067 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
7068    arguments to the call, and TYPE is its return type.
7069    Return NULL_TREE if no simplification can be made.  */
7070
7071 static tree
7072 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
7073 {
7074   if (!validate_arg (arg1, POINTER_TYPE)
7075       || !validate_arg (arg2, INTEGER_TYPE)
7076       || !validate_arg (len, INTEGER_TYPE))
7077     return NULL_TREE;
7078   else
7079     {
7080       const char *p1;
7081
7082       if (TREE_CODE (arg2) != INTEGER_CST
7083           || !tree_fits_uhwi_p (len))
7084         return NULL_TREE;
7085
7086       p1 = c_getstr (arg1);
7087       if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
7088         {
7089           char c;
7090           const char *r;
7091           tree tem;
7092
7093           if (target_char_cast (arg2, &c))
7094             return NULL_TREE;
7095
7096           r = (const char *) memchr (p1, c, tree_to_uhwi (len));
7097
7098           if (r == NULL)
7099             return build_int_cst (TREE_TYPE (arg1), 0);
7100
7101           tem = fold_build_pointer_plus_hwi_loc (loc, arg1, r - p1);
7102           return fold_convert_loc (loc, type, tem);
7103         }
7104       return NULL_TREE;
7105     }
7106 }
7107
7108 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
7109    Return NULL_TREE if no simplification can be made.  */
7110
7111 static tree
7112 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
7113 {
7114   if (!validate_arg (arg1, POINTER_TYPE)
7115       || !validate_arg (arg2, POINTER_TYPE)
7116       || !validate_arg (len, INTEGER_TYPE))
7117     return NULL_TREE;
7118
7119   /* If the LEN parameter is zero, return zero.  */
7120   if (integer_zerop (len))
7121     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
7122                               arg1, arg2);
7123
7124   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
7125   if (operand_equal_p (arg1, arg2, 0))
7126     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
7127
7128   /* If len parameter is one, return an expression corresponding to
7129      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
7130   if (tree_fits_uhwi_p (len) && tree_to_uhwi (len) == 1)
7131     {
7132       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7133       tree cst_uchar_ptr_node
7134         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7135
7136       tree ind1
7137         = fold_convert_loc (loc, integer_type_node,
7138                             build1 (INDIRECT_REF, cst_uchar_node,
7139                                     fold_convert_loc (loc,
7140                                                       cst_uchar_ptr_node,
7141                                                       arg1)));
7142       tree ind2
7143         = fold_convert_loc (loc, integer_type_node,
7144                             build1 (INDIRECT_REF, cst_uchar_node,
7145                                     fold_convert_loc (loc,
7146                                                       cst_uchar_ptr_node,
7147                                                       arg2)));
7148       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
7149     }
7150
7151   return NULL_TREE;
7152 }
7153
7154 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
7155    Return NULL_TREE if no simplification can be made.  */
7156
7157 static tree
7158 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
7159 {
7160   if (!validate_arg (arg1, POINTER_TYPE)
7161       || !validate_arg (arg2, POINTER_TYPE))
7162     return NULL_TREE;
7163
7164   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
7165   if (operand_equal_p (arg1, arg2, 0))
7166     return integer_zero_node;
7167
7168   /* If the second arg is "", return *(const unsigned char*)arg1.  */
7169   const char *p2 = c_getstr (arg2);
7170   if (p2 && *p2 == '\0')
7171     {
7172       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7173       tree cst_uchar_ptr_node
7174         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7175
7176       return fold_convert_loc (loc, integer_type_node,
7177                                build1 (INDIRECT_REF, cst_uchar_node,
7178                                        fold_convert_loc (loc,
7179                                                          cst_uchar_ptr_node,
7180                                                          arg1)));
7181     }
7182
7183   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
7184   const char *p1 = c_getstr (arg1);
7185   if (p1 && *p1 == '\0')
7186     {
7187       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7188       tree cst_uchar_ptr_node
7189         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7190
7191       tree temp
7192         = fold_convert_loc (loc, integer_type_node,
7193                             build1 (INDIRECT_REF, cst_uchar_node,
7194                                     fold_convert_loc (loc,
7195                                                       cst_uchar_ptr_node,
7196                                                       arg2)));
7197       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
7198     }
7199
7200   return NULL_TREE;
7201 }
7202
7203 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
7204    Return NULL_TREE if no simplification can be made.  */
7205
7206 static tree
7207 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
7208 {
7209   if (!validate_arg (arg1, POINTER_TYPE)
7210       || !validate_arg (arg2, POINTER_TYPE)
7211       || !validate_arg (len, INTEGER_TYPE))
7212     return NULL_TREE;
7213
7214   /* If the LEN parameter is zero, return zero.  */
7215   if (integer_zerop (len))
7216     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
7217                               arg1, arg2);
7218
7219   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
7220   if (operand_equal_p (arg1, arg2, 0))
7221     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
7222
7223   /* If the second arg is "", and the length is greater than zero,
7224      return *(const unsigned char*)arg1.  */
7225   const char *p2 = c_getstr (arg2);
7226   if (p2 && *p2 == '\0'
7227       && TREE_CODE (len) == INTEGER_CST
7228       && tree_int_cst_sgn (len) == 1)
7229     {
7230       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7231       tree cst_uchar_ptr_node
7232         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7233
7234       return fold_convert_loc (loc, integer_type_node,
7235                                build1 (INDIRECT_REF, cst_uchar_node,
7236                                        fold_convert_loc (loc,
7237                                                          cst_uchar_ptr_node,
7238                                                          arg1)));
7239     }
7240
7241   /* If the first arg is "", and the length is greater than zero,
7242      return -*(const unsigned char*)arg2.  */
7243   const char *p1 = c_getstr (arg1);
7244   if (p1 && *p1 == '\0'
7245       && TREE_CODE (len) == INTEGER_CST
7246       && tree_int_cst_sgn (len) == 1)
7247     {
7248       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7249       tree cst_uchar_ptr_node
7250         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7251
7252       tree temp = fold_convert_loc (loc, integer_type_node,
7253                                     build1 (INDIRECT_REF, cst_uchar_node,
7254                                             fold_convert_loc (loc,
7255                                                               cst_uchar_ptr_node,
7256                                                               arg2)));
7257       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
7258     }
7259
7260   /* If len parameter is one, return an expression corresponding to
7261      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
7262   if (tree_fits_uhwi_p (len) && tree_to_uhwi (len) == 1)
7263     {
7264       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7265       tree cst_uchar_ptr_node
7266         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7267
7268       tree ind1 = fold_convert_loc (loc, integer_type_node,
7269                                     build1 (INDIRECT_REF, cst_uchar_node,
7270                                             fold_convert_loc (loc,
7271                                                               cst_uchar_ptr_node,
7272                                                               arg1)));
7273       tree ind2 = fold_convert_loc (loc, integer_type_node,
7274                                     build1 (INDIRECT_REF, cst_uchar_node,
7275                                             fold_convert_loc (loc,
7276                                                               cst_uchar_ptr_node,
7277                                                               arg2)));
7278       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
7279     }
7280
7281   return NULL_TREE;
7282 }
7283
7284 /* Fold a call to builtin isascii with argument ARG.  */
7285
7286 static tree
7287 fold_builtin_isascii (location_t loc, tree arg)
7288 {
7289   if (!validate_arg (arg, INTEGER_TYPE))
7290     return NULL_TREE;
7291   else
7292     {
7293       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
7294       arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
7295                          build_int_cst (integer_type_node,
7296                                         ~ (unsigned HOST_WIDE_INT) 0x7f));
7297       return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
7298                               arg, integer_zero_node);
7299     }
7300 }
7301
7302 /* Fold a call to builtin toascii with argument ARG.  */
7303
7304 static tree
7305 fold_builtin_toascii (location_t loc, tree arg)
7306 {
7307   if (!validate_arg (arg, INTEGER_TYPE))
7308     return NULL_TREE;
7309
7310   /* Transform toascii(c) -> (c & 0x7f).  */
7311   return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
7312                           build_int_cst (integer_type_node, 0x7f));
7313 }
7314
7315 /* Fold a call to builtin isdigit with argument ARG.  */
7316
7317 static tree
7318 fold_builtin_isdigit (location_t loc, tree arg)
7319 {
7320   if (!validate_arg (arg, INTEGER_TYPE))
7321     return NULL_TREE;
7322   else
7323     {
7324       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
7325       /* According to the C standard, isdigit is unaffected by locale.
7326          However, it definitely is affected by the target character set.  */
7327       unsigned HOST_WIDE_INT target_digit0
7328         = lang_hooks.to_target_charset ('0');
7329
7330       if (target_digit0 == 0)
7331         return NULL_TREE;
7332
7333       arg = fold_convert_loc (loc, unsigned_type_node, arg);
7334       arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
7335                          build_int_cst (unsigned_type_node, target_digit0));
7336       return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
7337                           build_int_cst (unsigned_type_node, 9));
7338     }
7339 }
7340
7341 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
7342
7343 static tree
7344 fold_builtin_fabs (location_t loc, tree arg, tree type)
7345 {
7346   if (!validate_arg (arg, REAL_TYPE))
7347     return NULL_TREE;
7348
7349   arg = fold_convert_loc (loc, type, arg);
7350   return fold_build1_loc (loc, ABS_EXPR, type, arg);
7351 }
7352
7353 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
7354
7355 static tree
7356 fold_builtin_abs (location_t loc, tree arg, tree type)
7357 {
7358   if (!validate_arg (arg, INTEGER_TYPE))
7359     return NULL_TREE;
7360
7361   arg = fold_convert_loc (loc, type, arg);
7362   return fold_build1_loc (loc, ABS_EXPR, type, arg);
7363 }
7364
7365 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012].  */
7366
7367 static tree
7368 fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type)
7369 {
7370   /* ??? Only expand to FMA_EXPR if it's directly supported.  */
7371   if (validate_arg (arg0, REAL_TYPE)
7372       && validate_arg (arg1, REAL_TYPE)
7373       && validate_arg (arg2, REAL_TYPE)
7374       && optab_handler (fma_optab, TYPE_MODE (type)) != CODE_FOR_nothing)
7375     return fold_build3_loc (loc, FMA_EXPR, type, arg0, arg1, arg2);
7376
7377   return NULL_TREE;
7378 }
7379
7380 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
7381
7382 static tree
7383 fold_builtin_carg (location_t loc, tree arg, tree type)
7384 {
7385   if (validate_arg (arg, COMPLEX_TYPE)
7386       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7387     {
7388       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
7389
7390       if (atan2_fn)
7391         {
7392           tree new_arg = builtin_save_expr (arg);
7393           tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
7394           tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
7395           return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
7396         }
7397     }
7398
7399   return NULL_TREE;
7400 }
7401
7402 /* Fold a call to builtin frexp, we can assume the base is 2.  */
7403
7404 static tree
7405 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
7406 {
7407   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
7408     return NULL_TREE;
7409
7410   STRIP_NOPS (arg0);
7411
7412   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
7413     return NULL_TREE;
7414
7415   arg1 = build_fold_indirect_ref_loc (loc, arg1);
7416
7417   /* Proceed if a valid pointer type was passed in.  */
7418   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
7419     {
7420       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
7421       tree frac, exp;
7422
7423       switch (value->cl)
7424       {
7425       case rvc_zero:
7426         /* For +-0, return (*exp = 0, +-0).  */
7427         exp = integer_zero_node;
7428         frac = arg0;
7429         break;
7430       case rvc_nan:
7431       case rvc_inf:
7432         /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
7433         return omit_one_operand_loc (loc, rettype, arg0, arg1);
7434       case rvc_normal:
7435         {
7436           /* Since the frexp function always expects base 2, and in
7437              GCC normalized significands are already in the range
7438              [0.5, 1.0), we have exactly what frexp wants.  */
7439           REAL_VALUE_TYPE frac_rvt = *value;
7440           SET_REAL_EXP (&frac_rvt, 0);
7441           frac = build_real (rettype, frac_rvt);
7442           exp = build_int_cst (integer_type_node, REAL_EXP (value));
7443         }
7444         break;
7445       default:
7446         gcc_unreachable ();
7447       }
7448
7449       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
7450       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
7451       TREE_SIDE_EFFECTS (arg1) = 1;
7452       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
7453     }
7454
7455   return NULL_TREE;
7456 }
7457
7458 /* Fold a call to builtin modf.  */
7459
7460 static tree
7461 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
7462 {
7463   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
7464     return NULL_TREE;
7465
7466   STRIP_NOPS (arg0);
7467
7468   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
7469     return NULL_TREE;
7470
7471   arg1 = build_fold_indirect_ref_loc (loc, arg1);
7472
7473   /* Proceed if a valid pointer type was passed in.  */
7474   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
7475     {
7476       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
7477       REAL_VALUE_TYPE trunc, frac;
7478
7479       switch (value->cl)
7480       {
7481       case rvc_nan:
7482       case rvc_zero:
7483         /* For +-NaN or +-0, return (*arg1 = arg0, arg0).  */
7484         trunc = frac = *value;
7485         break;
7486       case rvc_inf:
7487         /* For +-Inf, return (*arg1 = arg0, +-0).  */
7488         frac = dconst0;
7489         frac.sign = value->sign;
7490         trunc = *value;
7491         break;
7492       case rvc_normal:
7493         /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)).  */
7494         real_trunc (&trunc, VOIDmode, value);
7495         real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
7496         /* If the original number was negative and already
7497            integral, then the fractional part is -0.0.  */
7498         if (value->sign && frac.cl == rvc_zero)
7499           frac.sign = value->sign;
7500         break;
7501       }
7502
7503       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
7504       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
7505                           build_real (rettype, trunc));
7506       TREE_SIDE_EFFECTS (arg1) = 1;
7507       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
7508                           build_real (rettype, frac));
7509     }
7510
7511   return NULL_TREE;
7512 }
7513
7514 /* Given a location LOC, an interclass builtin function decl FNDECL
7515    and its single argument ARG, return an folded expression computing
7516    the same, or NULL_TREE if we either couldn't or didn't want to fold
7517    (the latter happen if there's an RTL instruction available).  */
7518
7519 static tree
7520 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
7521 {
7522   machine_mode mode;
7523
7524   if (!validate_arg (arg, REAL_TYPE))
7525     return NULL_TREE;
7526
7527   if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
7528     return NULL_TREE;
7529
7530   mode = TYPE_MODE (TREE_TYPE (arg));
7531
7532   /* If there is no optab, try generic code.  */
7533   switch (DECL_FUNCTION_CODE (fndecl))
7534     {
7535       tree result;
7536
7537     CASE_FLT_FN (BUILT_IN_ISINF):
7538       {
7539         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
7540         tree const isgr_fn = builtin_decl_explicit (BUILT_IN_ISGREATER);
7541         tree const type = TREE_TYPE (arg);
7542         REAL_VALUE_TYPE r;
7543         char buf[128];
7544
7545         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
7546         real_from_string (&r, buf);
7547         result = build_call_expr (isgr_fn, 2,
7548                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
7549                                   build_real (type, r));
7550         return result;
7551       }
7552     CASE_FLT_FN (BUILT_IN_FINITE):
7553     case BUILT_IN_ISFINITE:
7554       {
7555         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
7556         tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
7557         tree const type = TREE_TYPE (arg);
7558         REAL_VALUE_TYPE r;
7559         char buf[128];
7560
7561         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
7562         real_from_string (&r, buf);
7563         result = build_call_expr (isle_fn, 2,
7564                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
7565                                   build_real (type, r));
7566         /*result = fold_build2_loc (loc, UNGT_EXPR,
7567                                   TREE_TYPE (TREE_TYPE (fndecl)),
7568                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
7569                                   build_real (type, r));
7570         result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
7571                                   TREE_TYPE (TREE_TYPE (fndecl)),
7572                                   result);*/
7573         return result;
7574       }
7575     case BUILT_IN_ISNORMAL:
7576       {
7577         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
7578            islessequal(fabs(x),DBL_MAX).  */
7579         tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
7580         tree const isge_fn = builtin_decl_explicit (BUILT_IN_ISGREATEREQUAL);
7581         tree const type = TREE_TYPE (arg);
7582         REAL_VALUE_TYPE rmax, rmin;
7583         char buf[128];
7584
7585         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
7586         real_from_string (&rmax, buf);
7587         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
7588         real_from_string (&rmin, buf);
7589         arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
7590         result = build_call_expr (isle_fn, 2, arg,
7591                                   build_real (type, rmax));
7592         result = fold_build2 (BIT_AND_EXPR, integer_type_node, result,
7593                               build_call_expr (isge_fn, 2, arg,
7594                                                build_real (type, rmin)));
7595         return result;
7596       }
7597     default:
7598       break;
7599     }
7600
7601   return NULL_TREE;
7602 }
7603
7604 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
7605    ARG is the argument for the call.  */
7606
7607 static tree
7608 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
7609 {
7610   tree type = TREE_TYPE (TREE_TYPE (fndecl));
7611
7612   if (!validate_arg (arg, REAL_TYPE))
7613     return NULL_TREE;
7614
7615   switch (builtin_index)
7616     {
7617     case BUILT_IN_ISINF:
7618       if (!HONOR_INFINITIES (arg))
7619         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
7620
7621       return NULL_TREE;
7622
7623     case BUILT_IN_ISINF_SIGN:
7624       {
7625         /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
7626         /* In a boolean context, GCC will fold the inner COND_EXPR to
7627            1.  So e.g. "if (isinf_sign(x))" would be folded to just
7628            "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
7629         tree signbit_fn = mathfn_built_in_1
7630           (TREE_TYPE (arg), CFN_BUILT_IN_SIGNBIT, 0);
7631         tree isinf_fn = builtin_decl_explicit (BUILT_IN_ISINF);
7632         tree tmp = NULL_TREE;
7633
7634         arg = builtin_save_expr (arg);
7635
7636         if (signbit_fn && isinf_fn)
7637           {
7638             tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
7639             tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
7640
7641             signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
7642                                         signbit_call, integer_zero_node);
7643             isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
7644                                       isinf_call, integer_zero_node);
7645
7646             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
7647                                integer_minus_one_node, integer_one_node);
7648             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
7649                                isinf_call, tmp,
7650                                integer_zero_node);
7651           }
7652
7653         return tmp;
7654       }
7655
7656     case BUILT_IN_ISFINITE:
7657       if (!HONOR_NANS (arg)
7658           && !HONOR_INFINITIES (arg))
7659         return omit_one_operand_loc (loc, type, integer_one_node, arg);
7660
7661       return NULL_TREE;
7662
7663     case BUILT_IN_ISNAN:
7664       if (!HONOR_NANS (arg))
7665         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
7666
7667       arg = builtin_save_expr (arg);
7668       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
7669
7670     default:
7671       gcc_unreachable ();
7672     }
7673 }
7674
7675 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
7676    This builtin will generate code to return the appropriate floating
7677    point classification depending on the value of the floating point
7678    number passed in.  The possible return values must be supplied as
7679    int arguments to the call in the following order: FP_NAN, FP_INFINITE,
7680    FP_NORMAL, FP_SUBNORMAL and FP_ZERO.  The ellipses is for exactly
7681    one floating point argument which is "type generic".  */
7682
7683 static tree
7684 fold_builtin_fpclassify (location_t loc, tree *args, int nargs)
7685 {
7686   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
7687     arg, type, res, tmp;
7688   machine_mode mode;
7689   REAL_VALUE_TYPE r;
7690   char buf[128];
7691
7692   /* Verify the required arguments in the original call.  */
7693   if (nargs != 6
7694       || !validate_arg (args[0], INTEGER_TYPE)
7695       || !validate_arg (args[1], INTEGER_TYPE)
7696       || !validate_arg (args[2], INTEGER_TYPE)
7697       || !validate_arg (args[3], INTEGER_TYPE)
7698       || !validate_arg (args[4], INTEGER_TYPE)
7699       || !validate_arg (args[5], REAL_TYPE))
7700     return NULL_TREE;
7701
7702   fp_nan = args[0];
7703   fp_infinite = args[1];
7704   fp_normal = args[2];
7705   fp_subnormal = args[3];
7706   fp_zero = args[4];
7707   arg = args[5];
7708   type = TREE_TYPE (arg);
7709   mode = TYPE_MODE (type);
7710   arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
7711
7712   /* fpclassify(x) ->
7713        isnan(x) ? FP_NAN :
7714          (fabs(x) == Inf ? FP_INFINITE :
7715            (fabs(x) >= DBL_MIN ? FP_NORMAL :
7716              (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
7717
7718   tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
7719                      build_real (type, dconst0));
7720   res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
7721                      tmp, fp_zero, fp_subnormal);
7722
7723   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
7724   real_from_string (&r, buf);
7725   tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
7726                      arg, build_real (type, r));
7727   res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
7728
7729   if (HONOR_INFINITIES (mode))
7730     {
7731       real_inf (&r);
7732       tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
7733                          build_real (type, r));
7734       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
7735                          fp_infinite, res);
7736     }
7737
7738   if (HONOR_NANS (mode))
7739     {
7740       tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
7741       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
7742     }
7743
7744   return res;
7745 }
7746
7747 /* Fold a call to an unordered comparison function such as
7748    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
7749    being called and ARG0 and ARG1 are the arguments for the call.
7750    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
7751    the opposite of the desired result.  UNORDERED_CODE is used
7752    for modes that can hold NaNs and ORDERED_CODE is used for
7753    the rest.  */
7754
7755 static tree
7756 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
7757                             enum tree_code unordered_code,
7758                             enum tree_code ordered_code)
7759 {
7760   tree type = TREE_TYPE (TREE_TYPE (fndecl));
7761   enum tree_code code;
7762   tree type0, type1;
7763   enum tree_code code0, code1;
7764   tree cmp_type = NULL_TREE;
7765
7766   type0 = TREE_TYPE (arg0);
7767   type1 = TREE_TYPE (arg1);
7768
7769   code0 = TREE_CODE (type0);
7770   code1 = TREE_CODE (type1);
7771
7772   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
7773     /* Choose the wider of two real types.  */
7774     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
7775       ? type0 : type1;
7776   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
7777     cmp_type = type0;
7778   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
7779     cmp_type = type1;
7780
7781   arg0 = fold_convert_loc (loc, cmp_type, arg0);
7782   arg1 = fold_convert_loc (loc, cmp_type, arg1);
7783
7784   if (unordered_code == UNORDERED_EXPR)
7785     {
7786       if (!HONOR_NANS (arg0))
7787         return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
7788       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
7789     }
7790
7791   code = HONOR_NANS (arg0) ? unordered_code : ordered_code;
7792   return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
7793                       fold_build2_loc (loc, code, type, arg0, arg1));
7794 }
7795
7796 /* Fold __builtin_{,s,u}{add,sub,mul}{,l,ll}_overflow, either into normal
7797    arithmetics if it can never overflow, or into internal functions that
7798    return both result of arithmetics and overflowed boolean flag in
7799    a complex integer result, or some other check for overflow.  */
7800
7801 static tree
7802 fold_builtin_arith_overflow (location_t loc, enum built_in_function fcode,
7803                              tree arg0, tree arg1, tree arg2)
7804 {
7805   enum internal_fn ifn = IFN_LAST;
7806   tree type = TREE_TYPE (TREE_TYPE (arg2));
7807   tree mem_arg2 = build_fold_indirect_ref_loc (loc, arg2);
7808   switch (fcode)
7809     {
7810     case BUILT_IN_ADD_OVERFLOW:
7811     case BUILT_IN_SADD_OVERFLOW:
7812     case BUILT_IN_SADDL_OVERFLOW:
7813     case BUILT_IN_SADDLL_OVERFLOW:
7814     case BUILT_IN_UADD_OVERFLOW:
7815     case BUILT_IN_UADDL_OVERFLOW:
7816     case BUILT_IN_UADDLL_OVERFLOW:
7817       ifn = IFN_ADD_OVERFLOW;
7818       break;
7819     case BUILT_IN_SUB_OVERFLOW:
7820     case BUILT_IN_SSUB_OVERFLOW:
7821     case BUILT_IN_SSUBL_OVERFLOW:
7822     case BUILT_IN_SSUBLL_OVERFLOW:
7823     case BUILT_IN_USUB_OVERFLOW:
7824     case BUILT_IN_USUBL_OVERFLOW:
7825     case BUILT_IN_USUBLL_OVERFLOW:
7826       ifn = IFN_SUB_OVERFLOW;
7827       break;
7828     case BUILT_IN_MUL_OVERFLOW:
7829     case BUILT_IN_SMUL_OVERFLOW:
7830     case BUILT_IN_SMULL_OVERFLOW:
7831     case BUILT_IN_SMULLL_OVERFLOW:
7832     case BUILT_IN_UMUL_OVERFLOW:
7833     case BUILT_IN_UMULL_OVERFLOW:
7834     case BUILT_IN_UMULLL_OVERFLOW:
7835       ifn = IFN_MUL_OVERFLOW;
7836       break;
7837     default:
7838       gcc_unreachable ();
7839     }
7840   tree ctype = build_complex_type (type);
7841   tree call = build_call_expr_internal_loc (loc, ifn, ctype,
7842                                             2, arg0, arg1);
7843   tree tgt = save_expr (call);
7844   tree intres = build1_loc (loc, REALPART_EXPR, type, tgt);
7845   tree ovfres = build1_loc (loc, IMAGPART_EXPR, type, tgt);
7846   ovfres = fold_convert_loc (loc, boolean_type_node, ovfres);
7847   tree store
7848     = fold_build2_loc (loc, MODIFY_EXPR, void_type_node, mem_arg2, intres);
7849   return build2_loc (loc, COMPOUND_EXPR, boolean_type_node, store, ovfres);
7850 }
7851
7852 /* Fold a call to built-in function FNDECL with 0 arguments.
7853    This function returns NULL_TREE if no simplification was possible.  */
7854
7855 static tree
7856 fold_builtin_0 (location_t loc, tree fndecl)
7857 {
7858   tree type = TREE_TYPE (TREE_TYPE (fndecl));
7859   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7860   switch (fcode)
7861     {
7862     CASE_FLT_FN (BUILT_IN_INF):
7863     case BUILT_IN_INFD32:
7864     case BUILT_IN_INFD64:
7865     case BUILT_IN_INFD128:
7866       return fold_builtin_inf (loc, type, true);
7867
7868     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
7869       return fold_builtin_inf (loc, type, false);
7870
7871     case BUILT_IN_CLASSIFY_TYPE:
7872       return fold_builtin_classify_type (NULL_TREE);
7873
7874     default:
7875       break;
7876     }
7877   return NULL_TREE;
7878 }
7879
7880 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
7881    This function returns NULL_TREE if no simplification was possible.  */
7882
7883 static tree
7884 fold_builtin_1 (location_t loc, tree fndecl, tree arg0)
7885 {
7886   tree type = TREE_TYPE (TREE_TYPE (fndecl));
7887   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7888
7889   if (TREE_CODE (arg0) == ERROR_MARK)
7890     return NULL_TREE;
7891
7892   if (tree ret = fold_const_call (as_combined_fn (fcode), type, arg0))
7893     return ret;
7894
7895   switch (fcode)
7896     {
7897     case BUILT_IN_CONSTANT_P:
7898       {
7899         tree val = fold_builtin_constant_p (arg0);
7900
7901         /* Gimplification will pull the CALL_EXPR for the builtin out of
7902            an if condition.  When not optimizing, we'll not CSE it back.
7903            To avoid link error types of regressions, return false now.  */
7904         if (!val && !optimize)
7905           val = integer_zero_node;
7906
7907         return val;
7908       }
7909
7910     case BUILT_IN_CLASSIFY_TYPE:
7911       return fold_builtin_classify_type (arg0);
7912
7913     case BUILT_IN_STRLEN:
7914       return fold_builtin_strlen (loc, type, arg0);
7915
7916     CASE_FLT_FN (BUILT_IN_FABS):
7917     case BUILT_IN_FABSD32:
7918     case BUILT_IN_FABSD64:
7919     case BUILT_IN_FABSD128:
7920       return fold_builtin_fabs (loc, arg0, type);
7921
7922     case BUILT_IN_ABS:
7923     case BUILT_IN_LABS:
7924     case BUILT_IN_LLABS:
7925     case BUILT_IN_IMAXABS:
7926       return fold_builtin_abs (loc, arg0, type);
7927
7928     CASE_FLT_FN (BUILT_IN_CONJ):
7929       if (validate_arg (arg0, COMPLEX_TYPE)
7930         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
7931         return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
7932     break;
7933
7934     CASE_FLT_FN (BUILT_IN_CREAL):
7935       if (validate_arg (arg0, COMPLEX_TYPE)
7936         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
7937         return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));
7938     break;
7939
7940     CASE_FLT_FN (BUILT_IN_CIMAG):
7941       if (validate_arg (arg0, COMPLEX_TYPE)
7942           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
7943         return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
7944     break;
7945
7946     CASE_FLT_FN (BUILT_IN_CARG):
7947       return fold_builtin_carg (loc, arg0, type);
7948
7949     case BUILT_IN_ISASCII:
7950       return fold_builtin_isascii (loc, arg0);
7951
7952     case BUILT_IN_TOASCII:
7953       return fold_builtin_toascii (loc, arg0);
7954
7955     case BUILT_IN_ISDIGIT:
7956       return fold_builtin_isdigit (loc, arg0);
7957
7958     CASE_FLT_FN (BUILT_IN_FINITE):
7959     case BUILT_IN_FINITED32:
7960     case BUILT_IN_FINITED64:
7961     case BUILT_IN_FINITED128:
7962     case BUILT_IN_ISFINITE:
7963       {
7964         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
7965         if (ret)
7966           return ret;
7967         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
7968       }
7969
7970     CASE_FLT_FN (BUILT_IN_ISINF):
7971     case BUILT_IN_ISINFD32:
7972     case BUILT_IN_ISINFD64:
7973     case BUILT_IN_ISINFD128:
7974       {
7975         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
7976         if (ret)
7977           return ret;
7978         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
7979       }
7980
7981     case BUILT_IN_ISNORMAL:
7982       return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
7983
7984     case BUILT_IN_ISINF_SIGN:
7985       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
7986
7987     CASE_FLT_FN (BUILT_IN_ISNAN):
7988     case BUILT_IN_ISNAND32:
7989     case BUILT_IN_ISNAND64:
7990     case BUILT_IN_ISNAND128:
7991       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
7992
7993     case BUILT_IN_FREE:
7994       if (integer_zerop (arg0))
7995         return build_empty_stmt (loc);
7996       break;
7997
7998     default:
7999       break;
8000     }
8001
8002   return NULL_TREE;
8003
8004 }
8005
8006 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
8007    This function returns NULL_TREE if no simplification was possible.  */
8008
8009 static tree
8010 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1)
8011 {
8012   tree type = TREE_TYPE (TREE_TYPE (fndecl));
8013   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
8014
8015   if (TREE_CODE (arg0) == ERROR_MARK
8016       || TREE_CODE (arg1) == ERROR_MARK)
8017     return NULL_TREE;
8018
8019   if (tree ret = fold_const_call (as_combined_fn (fcode), type, arg0, arg1))
8020     return ret;
8021
8022   switch (fcode)
8023     {
8024     CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
8025     CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
8026       if (validate_arg (arg0, REAL_TYPE)
8027           && validate_arg (arg1, POINTER_TYPE))
8028         return do_mpfr_lgamma_r (arg0, arg1, type);
8029     break;
8030
8031     CASE_FLT_FN (BUILT_IN_FREXP):
8032       return fold_builtin_frexp (loc, arg0, arg1, type);
8033
8034     CASE_FLT_FN (BUILT_IN_MODF):
8035       return fold_builtin_modf (loc, arg0, arg1, type);
8036
8037     case BUILT_IN_STRSTR:
8038       return fold_builtin_strstr (loc, arg0, arg1, type);
8039
8040     case BUILT_IN_STRSPN:
8041       return fold_builtin_strspn (loc, arg0, arg1);
8042
8043     case BUILT_IN_STRCSPN:
8044       return fold_builtin_strcspn (loc, arg0, arg1);
8045
8046     case BUILT_IN_STRCHR:
8047     case BUILT_IN_INDEX:
8048       return fold_builtin_strchr (loc, arg0, arg1, type);
8049
8050     case BUILT_IN_STRRCHR:
8051     case BUILT_IN_RINDEX:
8052       return fold_builtin_strrchr (loc, arg0, arg1, type);
8053
8054     case BUILT_IN_STRCMP:
8055       return fold_builtin_strcmp (loc, arg0, arg1);
8056
8057     case BUILT_IN_STRPBRK:
8058       return fold_builtin_strpbrk (loc, arg0, arg1, type);
8059
8060     case BUILT_IN_EXPECT:
8061       return fold_builtin_expect (loc, arg0, arg1, NULL_TREE);
8062
8063     case BUILT_IN_ISGREATER:
8064       return fold_builtin_unordered_cmp (loc, fndecl,
8065                                          arg0, arg1, UNLE_EXPR, LE_EXPR);
8066     case BUILT_IN_ISGREATEREQUAL:
8067       return fold_builtin_unordered_cmp (loc, fndecl,
8068                                          arg0, arg1, UNLT_EXPR, LT_EXPR);
8069     case BUILT_IN_ISLESS:
8070       return fold_builtin_unordered_cmp (loc, fndecl,
8071                                          arg0, arg1, UNGE_EXPR, GE_EXPR);
8072     case BUILT_IN_ISLESSEQUAL:
8073       return fold_builtin_unordered_cmp (loc, fndecl,
8074                                          arg0, arg1, UNGT_EXPR, GT_EXPR);
8075     case BUILT_IN_ISLESSGREATER:
8076       return fold_builtin_unordered_cmp (loc, fndecl,
8077                                          arg0, arg1, UNEQ_EXPR, EQ_EXPR);
8078     case BUILT_IN_ISUNORDERED:
8079       return fold_builtin_unordered_cmp (loc, fndecl,
8080                                          arg0, arg1, UNORDERED_EXPR,
8081                                          NOP_EXPR);
8082
8083       /* We do the folding for va_start in the expander.  */
8084     case BUILT_IN_VA_START:
8085       break;
8086
8087     case BUILT_IN_OBJECT_SIZE:
8088       return fold_builtin_object_size (arg0, arg1);
8089
8090     case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
8091       return fold_builtin_atomic_always_lock_free (arg0, arg1);
8092
8093     case BUILT_IN_ATOMIC_IS_LOCK_FREE:
8094       return fold_builtin_atomic_is_lock_free (arg0, arg1);
8095
8096     default:
8097       break;
8098     }
8099   return NULL_TREE;
8100 }
8101
8102 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
8103    and ARG2.
8104    This function returns NULL_TREE if no simplification was possible.  */
8105
8106 static tree
8107 fold_builtin_3 (location_t loc, tree fndecl,
8108                 tree arg0, tree arg1, tree arg2)
8109 {
8110   tree type = TREE_TYPE (TREE_TYPE (fndecl));
8111   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
8112
8113   if (TREE_CODE (arg0) == ERROR_MARK
8114       || TREE_CODE (arg1) == ERROR_MARK
8115       || TREE_CODE (arg2) == ERROR_MARK)
8116     return NULL_TREE;
8117
8118   if (tree ret = fold_const_call (as_combined_fn (fcode), type,
8119                                   arg0, arg1, arg2))
8120     return ret;
8121
8122   switch (fcode)
8123     {
8124
8125     CASE_FLT_FN (BUILT_IN_SINCOS):
8126       return fold_builtin_sincos (loc, arg0, arg1, arg2);
8127
8128     CASE_FLT_FN (BUILT_IN_FMA):
8129       return fold_builtin_fma (loc, arg0, arg1, arg2, type);
8130
8131     CASE_FLT_FN (BUILT_IN_REMQUO):
8132       if (validate_arg (arg0, REAL_TYPE)
8133           && validate_arg (arg1, REAL_TYPE)
8134           && validate_arg (arg2, POINTER_TYPE))
8135         return do_mpfr_remquo (arg0, arg1, arg2);
8136     break;
8137
8138     case BUILT_IN_STRNCMP:
8139       return fold_builtin_strncmp (loc, arg0, arg1, arg2);
8140
8141     case BUILT_IN_MEMCHR:
8142       return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
8143
8144     case BUILT_IN_BCMP:
8145     case BUILT_IN_MEMCMP:
8146       return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
8147
8148     case BUILT_IN_EXPECT:
8149       return fold_builtin_expect (loc, arg0, arg1, arg2);
8150
8151     case BUILT_IN_ADD_OVERFLOW:
8152     case BUILT_IN_SUB_OVERFLOW:
8153     case BUILT_IN_MUL_OVERFLOW:
8154     case BUILT_IN_SADD_OVERFLOW:
8155     case BUILT_IN_SADDL_OVERFLOW:
8156     case BUILT_IN_SADDLL_OVERFLOW:
8157     case BUILT_IN_SSUB_OVERFLOW:
8158     case BUILT_IN_SSUBL_OVERFLOW:
8159     case BUILT_IN_SSUBLL_OVERFLOW:
8160     case BUILT_IN_SMUL_OVERFLOW:
8161     case BUILT_IN_SMULL_OVERFLOW:
8162     case BUILT_IN_SMULLL_OVERFLOW:
8163     case BUILT_IN_UADD_OVERFLOW:
8164     case BUILT_IN_UADDL_OVERFLOW:
8165     case BUILT_IN_UADDLL_OVERFLOW:
8166     case BUILT_IN_USUB_OVERFLOW:
8167     case BUILT_IN_USUBL_OVERFLOW:
8168     case BUILT_IN_USUBLL_OVERFLOW:
8169     case BUILT_IN_UMUL_OVERFLOW:
8170     case BUILT_IN_UMULL_OVERFLOW:
8171     case BUILT_IN_UMULLL_OVERFLOW:
8172       return fold_builtin_arith_overflow (loc, fcode, arg0, arg1, arg2);
8173
8174     default:
8175       break;
8176     }
8177   return NULL_TREE;
8178 }
8179
8180 /* Fold a call to built-in function FNDECL.  ARGS is an array of NARGS
8181    arguments.  IGNORE is true if the result of the
8182    function call is ignored.  This function returns NULL_TREE if no
8183    simplification was possible.  */
8184
8185 tree
8186 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool)
8187 {
8188   tree ret = NULL_TREE;
8189
8190   switch (nargs)
8191     {
8192     case 0:
8193       ret = fold_builtin_0 (loc, fndecl);
8194       break;
8195     case 1:
8196       ret = fold_builtin_1 (loc, fndecl, args[0]);
8197       break;
8198     case 2:
8199       ret = fold_builtin_2 (loc, fndecl, args[0], args[1]);
8200       break;
8201     case 3:
8202       ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2]);
8203       break;
8204     default:
8205       ret = fold_builtin_varargs (loc, fndecl, args, nargs);
8206       break;
8207     }
8208   if (ret)
8209     {
8210       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
8211       SET_EXPR_LOCATION (ret, loc);
8212       TREE_NO_WARNING (ret) = 1;
8213       return ret;
8214     }
8215   return NULL_TREE;
8216 }
8217
8218 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
8219    list ARGS along with N new arguments in NEWARGS.  SKIP is the number
8220    of arguments in ARGS to be omitted.  OLDNARGS is the number of
8221    elements in ARGS.  */
8222
8223 static tree
8224 rewrite_call_expr_valist (location_t loc, int oldnargs, tree *args,
8225                           int skip, tree fndecl, int n, va_list newargs)
8226 {
8227   int nargs = oldnargs - skip + n;
8228   tree *buffer;
8229
8230   if (n > 0)
8231     {
8232       int i, j;
8233
8234       buffer = XALLOCAVEC (tree, nargs);
8235       for (i = 0; i < n; i++)
8236         buffer[i] = va_arg (newargs, tree);
8237       for (j = skip; j < oldnargs; j++, i++)
8238         buffer[i] = args[j];
8239     }
8240   else
8241     buffer = args + skip;
8242
8243   return build_call_expr_loc_array (loc, fndecl, nargs, buffer);
8244 }
8245
8246 /* Return true if FNDECL shouldn't be folded right now.
8247    If a built-in function has an inline attribute always_inline
8248    wrapper, defer folding it after always_inline functions have
8249    been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
8250    might not be performed.  */
8251
8252 bool
8253 avoid_folding_inline_builtin (tree fndecl)
8254 {
8255   return (DECL_DECLARED_INLINE_P (fndecl)
8256           && DECL_DISREGARD_INLINE_LIMITS (fndecl)
8257           && cfun
8258           && !cfun->always_inline_functions_inlined
8259           && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
8260 }
8261
8262 /* A wrapper function for builtin folding that prevents warnings for
8263    "statement without effect" and the like, caused by removing the
8264    call node earlier than the warning is generated.  */
8265
8266 tree
8267 fold_call_expr (location_t loc, tree exp, bool ignore)
8268 {
8269   tree ret = NULL_TREE;
8270   tree fndecl = get_callee_fndecl (exp);
8271   if (fndecl
8272       && TREE_CODE (fndecl) == FUNCTION_DECL
8273       && DECL_BUILT_IN (fndecl)
8274       /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
8275          yet.  Defer folding until we see all the arguments
8276          (after inlining).  */
8277       && !CALL_EXPR_VA_ARG_PACK (exp))
8278     {
8279       int nargs = call_expr_nargs (exp);
8280
8281       /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
8282          instead last argument is __builtin_va_arg_pack ().  Defer folding
8283          even in that case, until arguments are finalized.  */
8284       if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
8285         {
8286           tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
8287           if (fndecl2
8288               && TREE_CODE (fndecl2) == FUNCTION_DECL
8289               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
8290               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
8291             return NULL_TREE;
8292         }
8293
8294       if (avoid_folding_inline_builtin (fndecl))
8295         return NULL_TREE;
8296
8297       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
8298         return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
8299                                      CALL_EXPR_ARGP (exp), ignore);
8300       else
8301         {
8302           tree *args = CALL_EXPR_ARGP (exp);
8303           ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
8304           if (ret)
8305             return ret;
8306         }
8307     }
8308   return NULL_TREE;
8309 }
8310
8311 /* Fold a CALL_EXPR with type TYPE with FN as the function expression.
8312    N arguments are passed in the array ARGARRAY.  Return a folded
8313    expression or NULL_TREE if no simplification was possible.  */
8314
8315 tree
8316 fold_builtin_call_array (location_t loc, tree,
8317                          tree fn,
8318                          int n,
8319                          tree *argarray)
8320 {
8321   if (TREE_CODE (fn) != ADDR_EXPR)
8322     return NULL_TREE;
8323
8324   tree fndecl = TREE_OPERAND (fn, 0);
8325   if (TREE_CODE (fndecl) == FUNCTION_DECL
8326       && DECL_BUILT_IN (fndecl))
8327     {
8328       /* If last argument is __builtin_va_arg_pack (), arguments to this
8329          function are not finalized yet.  Defer folding until they are.  */
8330       if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
8331         {
8332           tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
8333           if (fndecl2
8334               && TREE_CODE (fndecl2) == FUNCTION_DECL
8335               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
8336               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
8337             return NULL_TREE;
8338         }
8339       if (avoid_folding_inline_builtin (fndecl))
8340         return NULL_TREE;
8341       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
8342         return targetm.fold_builtin (fndecl, n, argarray, false);
8343       else
8344         return fold_builtin_n (loc, fndecl, argarray, n, false);
8345     }
8346
8347   return NULL_TREE;
8348 }
8349
8350 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
8351    along with N new arguments specified as the "..." parameters.  SKIP
8352    is the number of arguments in EXP to be omitted.  This function is used
8353    to do varargs-to-varargs transformations.  */
8354
8355 static tree
8356 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
8357 {
8358   va_list ap;
8359   tree t;
8360
8361   va_start (ap, n);
8362   t = rewrite_call_expr_valist (loc, call_expr_nargs (exp),
8363                                 CALL_EXPR_ARGP (exp), skip, fndecl, n, ap);
8364   va_end (ap);
8365
8366   return t;
8367 }
8368
8369 /* Validate a single argument ARG against a tree code CODE representing
8370    a type.  */
8371
8372 static bool
8373 validate_arg (const_tree arg, enum tree_code code)
8374 {
8375   if (!arg)
8376     return false;
8377   else if (code == POINTER_TYPE)
8378     return POINTER_TYPE_P (TREE_TYPE (arg));
8379   else if (code == INTEGER_TYPE)
8380     return INTEGRAL_TYPE_P (TREE_TYPE (arg));
8381   return code == TREE_CODE (TREE_TYPE (arg));
8382 }
8383
8384 /* This function validates the types of a function call argument list
8385    against a specified list of tree_codes.  If the last specifier is a 0,
8386    that represents an ellipses, otherwise the last specifier must be a
8387    VOID_TYPE.
8388
8389    This is the GIMPLE version of validate_arglist.  Eventually we want to
8390    completely convert builtins.c to work from GIMPLEs and the tree based
8391    validate_arglist will then be removed.  */
8392
8393 bool
8394 validate_gimple_arglist (const gcall *call, ...)
8395 {
8396   enum tree_code code;
8397   bool res = 0;
8398   va_list ap;
8399   const_tree arg;
8400   size_t i;
8401
8402   va_start (ap, call);
8403   i = 0;
8404
8405   do
8406     {
8407       code = (enum tree_code) va_arg (ap, int);
8408       switch (code)
8409         {
8410         case 0:
8411           /* This signifies an ellipses, any further arguments are all ok.  */
8412           res = true;
8413           goto end;
8414         case VOID_TYPE:
8415           /* This signifies an endlink, if no arguments remain, return
8416              true, otherwise return false.  */
8417           res = (i == gimple_call_num_args (call));
8418           goto end;
8419         default:
8420           /* If no parameters remain or the parameter's code does not
8421              match the specified code, return false.  Otherwise continue
8422              checking any remaining arguments.  */
8423           arg = gimple_call_arg (call, i++);
8424           if (!validate_arg (arg, code))
8425             goto end;
8426           break;
8427         }
8428     }
8429   while (1);
8430
8431   /* We need gotos here since we can only have one VA_CLOSE in a
8432      function.  */
8433  end: ;
8434   va_end (ap);
8435
8436   return res;
8437 }
8438
8439 /* Default target-specific builtin expander that does nothing.  */
8440
8441 rtx
8442 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
8443                         rtx target ATTRIBUTE_UNUSED,
8444                         rtx subtarget ATTRIBUTE_UNUSED,
8445                         machine_mode mode ATTRIBUTE_UNUSED,
8446                         int ignore ATTRIBUTE_UNUSED)
8447 {
8448   return NULL_RTX;
8449 }
8450
8451 /* Returns true is EXP represents data that would potentially reside
8452    in a readonly section.  */
8453
8454 bool
8455 readonly_data_expr (tree exp)
8456 {
8457   STRIP_NOPS (exp);
8458
8459   if (TREE_CODE (exp) != ADDR_EXPR)
8460     return false;
8461
8462   exp = get_base_address (TREE_OPERAND (exp, 0));
8463   if (!exp)
8464     return false;
8465
8466   /* Make sure we call decl_readonly_section only for trees it
8467      can handle (since it returns true for everything it doesn't
8468      understand).  */
8469   if (TREE_CODE (exp) == STRING_CST
8470       || TREE_CODE (exp) == CONSTRUCTOR
8471       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
8472     return decl_readonly_section (exp, 0);
8473   else
8474     return false;
8475 }
8476
8477 /* Simplify a call to the strstr builtin.  S1 and S2 are the arguments
8478    to the call, and TYPE is its return type.
8479
8480    Return NULL_TREE if no simplification was possible, otherwise return the
8481    simplified form of the call as a tree.
8482
8483    The simplified form may be a constant or other expression which
8484    computes the same value, but in a more efficient manner (including
8485    calls to other builtin functions).
8486
8487    The call may contain arguments which need to be evaluated, but
8488    which are not useful to determine the result of the call.  In
8489    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8490    COMPOUND_EXPR will be an argument which must be evaluated.
8491    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8492    COMPOUND_EXPR in the chain will contain the tree for the simplified
8493    form of the builtin function call.  */
8494
8495 static tree
8496 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
8497 {
8498   if (!validate_arg (s1, POINTER_TYPE)
8499       || !validate_arg (s2, POINTER_TYPE))
8500     return NULL_TREE;
8501   else
8502     {
8503       tree fn;
8504       const char *p1, *p2;
8505
8506       p2 = c_getstr (s2);
8507       if (p2 == NULL)
8508         return NULL_TREE;
8509
8510       p1 = c_getstr (s1);
8511       if (p1 != NULL)
8512         {
8513           const char *r = strstr (p1, p2);
8514           tree tem;
8515
8516           if (r == NULL)
8517             return build_int_cst (TREE_TYPE (s1), 0);
8518
8519           /* Return an offset into the constant string argument.  */
8520           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8521           return fold_convert_loc (loc, type, tem);
8522         }
8523
8524       /* The argument is const char *, and the result is char *, so we need
8525          a type conversion here to avoid a warning.  */
8526       if (p2[0] == '\0')
8527         return fold_convert_loc (loc, type, s1);
8528
8529       if (p2[1] != '\0')
8530         return NULL_TREE;
8531
8532       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
8533       if (!fn)
8534         return NULL_TREE;
8535
8536       /* New argument list transforming strstr(s1, s2) to
8537          strchr(s1, s2[0]).  */
8538       return build_call_expr_loc (loc, fn, 2, s1,
8539                                   build_int_cst (integer_type_node, p2[0]));
8540     }
8541 }
8542
8543 /* Simplify a call to the strchr builtin.  S1 and S2 are the arguments to
8544    the call, and TYPE is its return type.
8545
8546    Return NULL_TREE if no simplification was possible, otherwise return the
8547    simplified form of the call as a tree.
8548
8549    The simplified form may be a constant or other expression which
8550    computes the same value, but in a more efficient manner (including
8551    calls to other builtin functions).
8552
8553    The call may contain arguments which need to be evaluated, but
8554    which are not useful to determine the result of the call.  In
8555    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8556    COMPOUND_EXPR will be an argument which must be evaluated.
8557    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8558    COMPOUND_EXPR in the chain will contain the tree for the simplified
8559    form of the builtin function call.  */
8560
8561 static tree
8562 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
8563 {
8564   if (!validate_arg (s1, POINTER_TYPE)
8565       || !validate_arg (s2, INTEGER_TYPE))
8566     return NULL_TREE;
8567   else
8568     {
8569       const char *p1;
8570
8571       if (TREE_CODE (s2) != INTEGER_CST)
8572         return NULL_TREE;
8573
8574       p1 = c_getstr (s1);
8575       if (p1 != NULL)
8576         {
8577           char c;
8578           const char *r;
8579           tree tem;
8580
8581           if (target_char_cast (s2, &c))
8582             return NULL_TREE;
8583
8584           r = strchr (p1, c);
8585
8586           if (r == NULL)
8587             return build_int_cst (TREE_TYPE (s1), 0);
8588
8589           /* Return an offset into the constant string argument.  */
8590           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8591           return fold_convert_loc (loc, type, tem);
8592         }
8593       return NULL_TREE;
8594     }
8595 }
8596
8597 /* Simplify a call to the strrchr builtin.  S1 and S2 are the arguments to
8598    the call, and TYPE is its return type.
8599
8600    Return NULL_TREE if no simplification was possible, otherwise return the
8601    simplified form of the call as a tree.
8602
8603    The simplified form may be a constant or other expression which
8604    computes the same value, but in a more efficient manner (including
8605    calls to other builtin functions).
8606
8607    The call may contain arguments which need to be evaluated, but
8608    which are not useful to determine the result of the call.  In
8609    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8610    COMPOUND_EXPR will be an argument which must be evaluated.
8611    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8612    COMPOUND_EXPR in the chain will contain the tree for the simplified
8613    form of the builtin function call.  */
8614
8615 static tree
8616 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
8617 {
8618   if (!validate_arg (s1, POINTER_TYPE)
8619       || !validate_arg (s2, INTEGER_TYPE))
8620     return NULL_TREE;
8621   else
8622     {
8623       tree fn;
8624       const char *p1;
8625
8626       if (TREE_CODE (s2) != INTEGER_CST)
8627         return NULL_TREE;
8628
8629       p1 = c_getstr (s1);
8630       if (p1 != NULL)
8631         {
8632           char c;
8633           const char *r;
8634           tree tem;
8635
8636           if (target_char_cast (s2, &c))
8637             return NULL_TREE;
8638
8639           r = strrchr (p1, c);
8640
8641           if (r == NULL)
8642             return build_int_cst (TREE_TYPE (s1), 0);
8643
8644           /* Return an offset into the constant string argument.  */
8645           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8646           return fold_convert_loc (loc, type, tem);
8647         }
8648
8649       if (! integer_zerop (s2))
8650         return NULL_TREE;
8651
8652       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
8653       if (!fn)
8654         return NULL_TREE;
8655
8656       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
8657       return build_call_expr_loc (loc, fn, 2, s1, s2);
8658     }
8659 }
8660
8661 /* Simplify a call to the strpbrk builtin.  S1 and S2 are the arguments
8662    to the call, and TYPE is its return type.
8663
8664    Return NULL_TREE if no simplification was possible, otherwise return the
8665    simplified form of the call as a tree.
8666
8667    The simplified form may be a constant or other expression which
8668    computes the same value, but in a more efficient manner (including
8669    calls to other builtin functions).
8670
8671    The call may contain arguments which need to be evaluated, but
8672    which are not useful to determine the result of the call.  In
8673    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8674    COMPOUND_EXPR will be an argument which must be evaluated.
8675    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8676    COMPOUND_EXPR in the chain will contain the tree for the simplified
8677    form of the builtin function call.  */
8678
8679 static tree
8680 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
8681 {
8682   if (!validate_arg (s1, POINTER_TYPE)
8683       || !validate_arg (s2, POINTER_TYPE))
8684     return NULL_TREE;
8685   else
8686     {
8687       tree fn;
8688       const char *p1, *p2;
8689
8690       p2 = c_getstr (s2);
8691       if (p2 == NULL)
8692         return NULL_TREE;
8693
8694       p1 = c_getstr (s1);
8695       if (p1 != NULL)
8696         {
8697           const char *r = strpbrk (p1, p2);
8698           tree tem;
8699
8700           if (r == NULL)
8701             return build_int_cst (TREE_TYPE (s1), 0);
8702
8703           /* Return an offset into the constant string argument.  */
8704           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8705           return fold_convert_loc (loc, type, tem);
8706         }
8707
8708       if (p2[0] == '\0')
8709         /* strpbrk(x, "") == NULL.
8710            Evaluate and ignore s1 in case it had side-effects.  */
8711         return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
8712
8713       if (p2[1] != '\0')
8714         return NULL_TREE;  /* Really call strpbrk.  */
8715
8716       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
8717       if (!fn)
8718         return NULL_TREE;
8719
8720       /* New argument list transforming strpbrk(s1, s2) to
8721          strchr(s1, s2[0]).  */
8722       return build_call_expr_loc (loc, fn, 2, s1,
8723                                   build_int_cst (integer_type_node, p2[0]));
8724     }
8725 }
8726
8727 /* Simplify a call to the strspn builtin.  S1 and S2 are the arguments
8728    to the call.
8729
8730    Return NULL_TREE if no simplification was possible, otherwise return the
8731    simplified form of the call as a tree.
8732
8733    The simplified form may be a constant or other expression which
8734    computes the same value, but in a more efficient manner (including
8735    calls to other builtin functions).
8736
8737    The call may contain arguments which need to be evaluated, but
8738    which are not useful to determine the result of the call.  In
8739    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8740    COMPOUND_EXPR will be an argument which must be evaluated.
8741    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8742    COMPOUND_EXPR in the chain will contain the tree for the simplified
8743    form of the builtin function call.  */
8744
8745 static tree
8746 fold_builtin_strspn (location_t loc, tree s1, tree s2)
8747 {
8748   if (!validate_arg (s1, POINTER_TYPE)
8749       || !validate_arg (s2, POINTER_TYPE))
8750     return NULL_TREE;
8751   else
8752     {
8753       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
8754
8755       /* If either argument is "", return NULL_TREE.  */
8756       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
8757         /* Evaluate and ignore both arguments in case either one has
8758            side-effects.  */
8759         return omit_two_operands_loc (loc, size_type_node, size_zero_node,
8760                                   s1, s2);
8761       return NULL_TREE;
8762     }
8763 }
8764
8765 /* Simplify a call to the strcspn builtin.  S1 and S2 are the arguments
8766    to the call.
8767
8768    Return NULL_TREE if no simplification was possible, otherwise return the
8769    simplified form of the call as a tree.
8770
8771    The simplified form may be a constant or other expression which
8772    computes the same value, but in a more efficient manner (including
8773    calls to other builtin functions).
8774
8775    The call may contain arguments which need to be evaluated, but
8776    which are not useful to determine the result of the call.  In
8777    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8778    COMPOUND_EXPR will be an argument which must be evaluated.
8779    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8780    COMPOUND_EXPR in the chain will contain the tree for the simplified
8781    form of the builtin function call.  */
8782
8783 static tree
8784 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
8785 {
8786   if (!validate_arg (s1, POINTER_TYPE)
8787       || !validate_arg (s2, POINTER_TYPE))
8788     return NULL_TREE;
8789   else
8790     {
8791       /* If the first argument is "", return NULL_TREE.  */
8792       const char *p1 = c_getstr (s1);
8793       if (p1 && *p1 == '\0')
8794         {
8795           /* Evaluate and ignore argument s2 in case it has
8796              side-effects.  */
8797           return omit_one_operand_loc (loc, size_type_node,
8798                                    size_zero_node, s2);
8799         }
8800
8801       /* If the second argument is "", return __builtin_strlen(s1).  */
8802       const char *p2 = c_getstr (s2);
8803       if (p2 && *p2 == '\0')
8804         {
8805           tree fn = builtin_decl_implicit (BUILT_IN_STRLEN);
8806
8807           /* If the replacement _DECL isn't initialized, don't do the
8808              transformation.  */
8809           if (!fn)
8810             return NULL_TREE;
8811
8812           return build_call_expr_loc (loc, fn, 1, s1);
8813         }
8814       return NULL_TREE;
8815     }
8816 }
8817
8818 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
8819    produced.  False otherwise.  This is done so that we don't output the error
8820    or warning twice or three times.  */
8821
8822 bool
8823 fold_builtin_next_arg (tree exp, bool va_start_p)
8824 {
8825   tree fntype = TREE_TYPE (current_function_decl);
8826   int nargs = call_expr_nargs (exp);
8827   tree arg;
8828   /* There is good chance the current input_location points inside the
8829      definition of the va_start macro (perhaps on the token for
8830      builtin) in a system header, so warnings will not be emitted.
8831      Use the location in real source code.  */
8832   source_location current_location =
8833     linemap_unwind_to_first_non_reserved_loc (line_table, input_location,
8834                                               NULL);
8835
8836   if (!stdarg_p (fntype))
8837     {
8838       error ("%<va_start%> used in function with fixed args");
8839       return true;
8840     }
8841
8842   if (va_start_p)
8843     {
8844       if (va_start_p && (nargs != 2))
8845         {
8846           error ("wrong number of arguments to function %<va_start%>");
8847           return true;
8848         }
8849       arg = CALL_EXPR_ARG (exp, 1);
8850     }
8851   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
8852      when we checked the arguments and if needed issued a warning.  */
8853   else
8854     {
8855       if (nargs == 0)
8856         {
8857           /* Evidently an out of date version of <stdarg.h>; can't validate
8858              va_start's second argument, but can still work as intended.  */
8859           warning_at (current_location,
8860                       OPT_Wvarargs,
8861                    "%<__builtin_next_arg%> called without an argument");
8862           return true;
8863         }
8864       else if (nargs > 1)
8865         {
8866           error ("wrong number of arguments to function %<__builtin_next_arg%>");
8867           return true;
8868         }
8869       arg = CALL_EXPR_ARG (exp, 0);
8870     }
8871
8872   if (TREE_CODE (arg) == SSA_NAME)
8873     arg = SSA_NAME_VAR (arg);
8874
8875   /* We destructively modify the call to be __builtin_va_start (ap, 0)
8876      or __builtin_next_arg (0) the first time we see it, after checking
8877      the arguments and if needed issuing a warning.  */
8878   if (!integer_zerop (arg))
8879     {
8880       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
8881
8882       /* Strip off all nops for the sake of the comparison.  This
8883          is not quite the same as STRIP_NOPS.  It does more.
8884          We must also strip off INDIRECT_EXPR for C++ reference
8885          parameters.  */
8886       while (CONVERT_EXPR_P (arg)
8887              || TREE_CODE (arg) == INDIRECT_REF)
8888         arg = TREE_OPERAND (arg, 0);
8889       if (arg != last_parm)
8890         {
8891           /* FIXME: Sometimes with the tree optimizers we can get the
8892              not the last argument even though the user used the last
8893              argument.  We just warn and set the arg to be the last
8894              argument so that we will get wrong-code because of
8895              it.  */
8896           warning_at (current_location,
8897                       OPT_Wvarargs,
8898                       "second parameter of %<va_start%> not last named argument");
8899         }
8900
8901       /* Undefined by C99 7.15.1.4p4 (va_start):
8902          "If the parameter parmN is declared with the register storage
8903          class, with a function or array type, or with a type that is
8904          not compatible with the type that results after application of
8905          the default argument promotions, the behavior is undefined."
8906       */
8907       else if (DECL_REGISTER (arg))
8908         {
8909           warning_at (current_location,
8910                       OPT_Wvarargs,
8911                       "undefined behaviour when second parameter of "
8912                       "%<va_start%> is declared with %<register%> storage");
8913         }
8914
8915       /* We want to verify the second parameter just once before the tree
8916          optimizers are run and then avoid keeping it in the tree,
8917          as otherwise we could warn even for correct code like:
8918          void foo (int i, ...)
8919          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
8920       if (va_start_p)
8921         CALL_EXPR_ARG (exp, 1) = integer_zero_node;
8922       else
8923         CALL_EXPR_ARG (exp, 0) = integer_zero_node;
8924     }
8925   return false;
8926 }
8927
8928
8929 /* Expand a call EXP to __builtin_object_size.  */
8930
8931 static rtx
8932 expand_builtin_object_size (tree exp)
8933 {
8934   tree ost;
8935   int object_size_type;
8936   tree fndecl = get_callee_fndecl (exp);
8937
8938   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
8939     {
8940       error ("%Kfirst argument of %D must be a pointer, second integer constant",
8941              exp, fndecl);
8942       expand_builtin_trap ();
8943       return const0_rtx;
8944     }
8945
8946   ost = CALL_EXPR_ARG (exp, 1);
8947   STRIP_NOPS (ost);
8948
8949   if (TREE_CODE (ost) != INTEGER_CST
8950       || tree_int_cst_sgn (ost) < 0
8951       || compare_tree_int (ost, 3) > 0)
8952     {
8953       error ("%Klast argument of %D is not integer constant between 0 and 3",
8954              exp, fndecl);
8955       expand_builtin_trap ();
8956       return const0_rtx;
8957     }
8958
8959   object_size_type = tree_to_shwi (ost);
8960
8961   return object_size_type < 2 ? constm1_rtx : const0_rtx;
8962 }
8963
8964 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
8965    FCODE is the BUILT_IN_* to use.
8966    Return NULL_RTX if we failed; the caller should emit a normal call,
8967    otherwise try to get the result in TARGET, if convenient (and in
8968    mode MODE if that's convenient).  */
8969
8970 static rtx
8971 expand_builtin_memory_chk (tree exp, rtx target, machine_mode mode,
8972                            enum built_in_function fcode)
8973 {
8974   tree dest, src, len, size;
8975
8976   if (!validate_arglist (exp,
8977                          POINTER_TYPE,
8978                          fcode == BUILT_IN_MEMSET_CHK
8979                          ? INTEGER_TYPE : POINTER_TYPE,
8980                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
8981     return NULL_RTX;
8982
8983   dest = CALL_EXPR_ARG (exp, 0);
8984   src = CALL_EXPR_ARG (exp, 1);
8985   len = CALL_EXPR_ARG (exp, 2);
8986   size = CALL_EXPR_ARG (exp, 3);
8987
8988   if (! tree_fits_uhwi_p (size))
8989     return NULL_RTX;
8990
8991   if (tree_fits_uhwi_p (len) || integer_all_onesp (size))
8992     {
8993       tree fn;
8994
8995       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
8996         {
8997           warning_at (tree_nonartificial_location (exp),
8998                       0, "%Kcall to %D will always overflow destination buffer",
8999                       exp, get_callee_fndecl (exp));
9000           return NULL_RTX;
9001         }
9002
9003       fn = NULL_TREE;
9004       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
9005          mem{cpy,pcpy,move,set} is available.  */
9006       switch (fcode)
9007         {
9008         case BUILT_IN_MEMCPY_CHK:
9009           fn = builtin_decl_explicit (BUILT_IN_MEMCPY);
9010           break;
9011         case BUILT_IN_MEMPCPY_CHK:
9012           fn = builtin_decl_explicit (BUILT_IN_MEMPCPY);
9013           break;
9014         case BUILT_IN_MEMMOVE_CHK:
9015           fn = builtin_decl_explicit (BUILT_IN_MEMMOVE);
9016           break;
9017         case BUILT_IN_MEMSET_CHK:
9018           fn = builtin_decl_explicit (BUILT_IN_MEMSET);
9019           break;
9020         default:
9021           break;
9022         }
9023
9024       if (! fn)
9025         return NULL_RTX;
9026
9027       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
9028       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
9029       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
9030       return expand_expr (fn, target, mode, EXPAND_NORMAL);
9031     }
9032   else if (fcode == BUILT_IN_MEMSET_CHK)
9033     return NULL_RTX;
9034   else
9035     {
9036       unsigned int dest_align = get_pointer_alignment (dest);
9037
9038       /* If DEST is not a pointer type, call the normal function.  */
9039       if (dest_align == 0)
9040         return NULL_RTX;
9041
9042       /* If SRC and DEST are the same (and not volatile), do nothing.  */
9043       if (operand_equal_p (src, dest, 0))
9044         {
9045           tree expr;
9046
9047           if (fcode != BUILT_IN_MEMPCPY_CHK)
9048             {
9049               /* Evaluate and ignore LEN in case it has side-effects.  */
9050               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
9051               return expand_expr (dest, target, mode, EXPAND_NORMAL);
9052             }
9053
9054           expr = fold_build_pointer_plus (dest, len);
9055           return expand_expr (expr, target, mode, EXPAND_NORMAL);
9056         }
9057
9058       /* __memmove_chk special case.  */
9059       if (fcode == BUILT_IN_MEMMOVE_CHK)
9060         {
9061           unsigned int src_align = get_pointer_alignment (src);
9062
9063           if (src_align == 0)
9064             return NULL_RTX;
9065
9066           /* If src is categorized for a readonly section we can use
9067              normal __memcpy_chk.  */
9068           if (readonly_data_expr (src))
9069             {
9070               tree fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
9071               if (!fn)
9072                 return NULL_RTX;
9073               fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
9074                                           dest, src, len, size);
9075               gcc_assert (TREE_CODE (fn) == CALL_EXPR);
9076               CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
9077               return expand_expr (fn, target, mode, EXPAND_NORMAL);
9078             }
9079         }
9080       return NULL_RTX;
9081     }
9082 }
9083
9084 /* Emit warning if a buffer overflow is detected at compile time.  */
9085
9086 static void
9087 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
9088 {
9089   int is_strlen = 0;
9090   tree len, size;
9091   location_t loc = tree_nonartificial_location (exp);
9092
9093   switch (fcode)
9094     {
9095     case BUILT_IN_STRCPY_CHK:
9096     case BUILT_IN_STPCPY_CHK:
9097     /* For __strcat_chk the warning will be emitted only if overflowing
9098        by at least strlen (dest) + 1 bytes.  */
9099     case BUILT_IN_STRCAT_CHK:
9100       len = CALL_EXPR_ARG (exp, 1);
9101       size = CALL_EXPR_ARG (exp, 2);
9102       is_strlen = 1;
9103       break;
9104     case BUILT_IN_STRNCAT_CHK:
9105     case BUILT_IN_STRNCPY_CHK:
9106     case BUILT_IN_STPNCPY_CHK:
9107       len = CALL_EXPR_ARG (exp, 2);
9108       size = CALL_EXPR_ARG (exp, 3);
9109       break;
9110     case BUILT_IN_SNPRINTF_CHK:
9111     case BUILT_IN_VSNPRINTF_CHK:
9112       len = CALL_EXPR_ARG (exp, 1);
9113       size = CALL_EXPR_ARG (exp, 3);
9114       break;
9115     default:
9116       gcc_unreachable ();
9117     }
9118
9119   if (!len || !size)
9120     return;
9121
9122   if (! tree_fits_uhwi_p (size) || integer_all_onesp (size))
9123     return;
9124
9125   if (is_strlen)
9126     {
9127       len = c_strlen (len, 1);
9128       if (! len || ! tree_fits_uhwi_p (len) || tree_int_cst_lt (len, size))
9129         return;
9130     }
9131   else if (fcode == BUILT_IN_STRNCAT_CHK)
9132     {
9133       tree src = CALL_EXPR_ARG (exp, 1);
9134       if (! src || ! tree_fits_uhwi_p (len) || tree_int_cst_lt (len, size))
9135         return;
9136       src = c_strlen (src, 1);
9137       if (! src || ! tree_fits_uhwi_p (src))
9138         {
9139           warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
9140                       exp, get_callee_fndecl (exp));
9141           return;
9142         }
9143       else if (tree_int_cst_lt (src, size))
9144         return;
9145     }
9146   else if (! tree_fits_uhwi_p (len) || ! tree_int_cst_lt (size, len))
9147     return;
9148
9149   warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
9150               exp, get_callee_fndecl (exp));
9151 }
9152
9153 /* Emit warning if a buffer overflow is detected at compile time
9154    in __sprintf_chk/__vsprintf_chk calls.  */
9155
9156 static void
9157 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
9158 {
9159   tree size, len, fmt;
9160   const char *fmt_str;
9161   int nargs = call_expr_nargs (exp);
9162
9163   /* Verify the required arguments in the original call.  */
9164
9165   if (nargs < 4)
9166     return;
9167   size = CALL_EXPR_ARG (exp, 2);
9168   fmt = CALL_EXPR_ARG (exp, 3);
9169
9170   if (! tree_fits_uhwi_p (size) || integer_all_onesp (size))
9171     return;
9172
9173   /* Check whether the format is a literal string constant.  */
9174   fmt_str = c_getstr (fmt);
9175   if (fmt_str == NULL)
9176     return;
9177
9178   if (!init_target_chars ())
9179     return;
9180
9181   /* If the format doesn't contain % args or %%, we know its size.  */
9182   if (strchr (fmt_str, target_percent) == 0)
9183     len = build_int_cstu (size_type_node, strlen (fmt_str));
9184   /* If the format is "%s" and first ... argument is a string literal,
9185      we know it too.  */
9186   else if (fcode == BUILT_IN_SPRINTF_CHK
9187            && strcmp (fmt_str, target_percent_s) == 0)
9188     {
9189       tree arg;
9190
9191       if (nargs < 5)
9192         return;
9193       arg = CALL_EXPR_ARG (exp, 4);
9194       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
9195         return;
9196
9197       len = c_strlen (arg, 1);
9198       if (!len || ! tree_fits_uhwi_p (len))
9199         return;
9200     }
9201   else
9202     return;
9203
9204   if (! tree_int_cst_lt (len, size))
9205     warning_at (tree_nonartificial_location (exp),
9206                 0, "%Kcall to %D will always overflow destination buffer",
9207                 exp, get_callee_fndecl (exp));
9208 }
9209
9210 /* Emit warning if a free is called with address of a variable.  */
9211
9212 static void
9213 maybe_emit_free_warning (tree exp)
9214 {
9215   tree arg = CALL_EXPR_ARG (exp, 0);
9216
9217   STRIP_NOPS (arg);
9218   if (TREE_CODE (arg) != ADDR_EXPR)
9219     return;
9220
9221   arg = get_base_address (TREE_OPERAND (arg, 0));
9222   if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
9223     return;
9224
9225   if (SSA_VAR_P (arg))
9226     warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
9227                 "%Kattempt to free a non-heap object %qD", exp, arg);
9228   else
9229     warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
9230                 "%Kattempt to free a non-heap object", exp);
9231 }
9232
9233 /* Fold a call to __builtin_object_size with arguments PTR and OST,
9234    if possible.  */
9235
9236 static tree
9237 fold_builtin_object_size (tree ptr, tree ost)
9238 {
9239   unsigned HOST_WIDE_INT bytes;
9240   int object_size_type;
9241
9242   if (!validate_arg (ptr, POINTER_TYPE)
9243       || !validate_arg (ost, INTEGER_TYPE))
9244     return NULL_TREE;
9245
9246   STRIP_NOPS (ost);
9247
9248   if (TREE_CODE (ost) != INTEGER_CST
9249       || tree_int_cst_sgn (ost) < 0
9250       || compare_tree_int (ost, 3) > 0)
9251     return NULL_TREE;
9252
9253   object_size_type = tree_to_shwi (ost);
9254
9255   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
9256      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
9257      and (size_t) 0 for types 2 and 3.  */
9258   if (TREE_SIDE_EFFECTS (ptr))
9259     return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
9260
9261   if (TREE_CODE (ptr) == ADDR_EXPR)
9262     {
9263       bytes = compute_builtin_object_size (ptr, object_size_type);
9264       if (wi::fits_to_tree_p (bytes, size_type_node))
9265         return build_int_cstu (size_type_node, bytes);
9266     }
9267   else if (TREE_CODE (ptr) == SSA_NAME)
9268     {
9269       /* If object size is not known yet, delay folding until
9270        later.  Maybe subsequent passes will help determining
9271        it.  */
9272       bytes = compute_builtin_object_size (ptr, object_size_type);
9273       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
9274           && wi::fits_to_tree_p (bytes, size_type_node))
9275         return build_int_cstu (size_type_node, bytes);
9276     }
9277
9278   return NULL_TREE;
9279 }
9280
9281 /* Builtins with folding operations that operate on "..." arguments
9282    need special handling; we need to store the arguments in a convenient
9283    data structure before attempting any folding.  Fortunately there are
9284    only a few builtins that fall into this category.  FNDECL is the
9285    function, EXP is the CALL_EXPR for the call.  */
9286
9287 static tree
9288 fold_builtin_varargs (location_t loc, tree fndecl, tree *args, int nargs)
9289 {
9290   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9291   tree ret = NULL_TREE;
9292
9293   switch (fcode)
9294     {
9295     case BUILT_IN_FPCLASSIFY:
9296       ret = fold_builtin_fpclassify (loc, args, nargs);
9297       break;
9298
9299     default:
9300       break;
9301     }
9302   if (ret)
9303     {
9304       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
9305       SET_EXPR_LOCATION (ret, loc);
9306       TREE_NO_WARNING (ret) = 1;
9307       return ret;
9308     }
9309   return NULL_TREE;
9310 }
9311
9312 /* Initialize format string characters in the target charset.  */
9313
9314 bool
9315 init_target_chars (void)
9316 {
9317   static bool init;
9318   if (!init)
9319     {
9320       target_newline = lang_hooks.to_target_charset ('\n');
9321       target_percent = lang_hooks.to_target_charset ('%');
9322       target_c = lang_hooks.to_target_charset ('c');
9323       target_s = lang_hooks.to_target_charset ('s');
9324       if (target_newline == 0 || target_percent == 0 || target_c == 0
9325           || target_s == 0)
9326         return false;
9327
9328       target_percent_c[0] = target_percent;
9329       target_percent_c[1] = target_c;
9330       target_percent_c[2] = '\0';
9331
9332       target_percent_s[0] = target_percent;
9333       target_percent_s[1] = target_s;
9334       target_percent_s[2] = '\0';
9335
9336       target_percent_s_newline[0] = target_percent;
9337       target_percent_s_newline[1] = target_s;
9338       target_percent_s_newline[2] = target_newline;
9339       target_percent_s_newline[3] = '\0';
9340
9341       init = true;
9342     }
9343   return true;
9344 }
9345
9346 /* Helper function for do_mpfr_arg*().  Ensure M is a normal number
9347    and no overflow/underflow occurred.  INEXACT is true if M was not
9348    exactly calculated.  TYPE is the tree type for the result.  This
9349    function assumes that you cleared the MPFR flags and then
9350    calculated M to see if anything subsequently set a flag prior to
9351    entering this function.  Return NULL_TREE if any checks fail.  */
9352
9353 static tree
9354 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
9355 {
9356   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
9357      overflow/underflow occurred.  If -frounding-math, proceed iff the
9358      result of calling FUNC was exact.  */
9359   if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
9360       && (!flag_rounding_math || !inexact))
9361     {
9362       REAL_VALUE_TYPE rr;
9363
9364       real_from_mpfr (&rr, m, type, GMP_RNDN);
9365       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
9366          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
9367          but the mpft_t is not, then we underflowed in the
9368          conversion.  */
9369       if (real_isfinite (&rr)
9370           && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
9371         {
9372           REAL_VALUE_TYPE rmode;
9373
9374           real_convert (&rmode, TYPE_MODE (type), &rr);
9375           /* Proceed iff the specified mode can hold the value.  */
9376           if (real_identical (&rmode, &rr))
9377             return build_real (type, rmode);
9378         }
9379     }
9380   return NULL_TREE;
9381 }
9382
9383 /* Helper function for do_mpc_arg*().  Ensure M is a normal complex
9384    number and no overflow/underflow occurred.  INEXACT is true if M
9385    was not exactly calculated.  TYPE is the tree type for the result.
9386    This function assumes that you cleared the MPFR flags and then
9387    calculated M to see if anything subsequently set a flag prior to
9388    entering this function.  Return NULL_TREE if any checks fail, if
9389    FORCE_CONVERT is true, then bypass the checks.  */
9390
9391 static tree
9392 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
9393 {
9394   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
9395      overflow/underflow occurred.  If -frounding-math, proceed iff the
9396      result of calling FUNC was exact.  */
9397   if (force_convert
9398       || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
9399           && !mpfr_overflow_p () && !mpfr_underflow_p ()
9400           && (!flag_rounding_math || !inexact)))
9401     {
9402       REAL_VALUE_TYPE re, im;
9403
9404       real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
9405       real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
9406       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
9407          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
9408          but the mpft_t is not, then we underflowed in the
9409          conversion.  */
9410       if (force_convert
9411           || (real_isfinite (&re) && real_isfinite (&im)
9412               && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
9413               && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
9414         {
9415           REAL_VALUE_TYPE re_mode, im_mode;
9416
9417           real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
9418           real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
9419           /* Proceed iff the specified mode can hold the value.  */
9420           if (force_convert
9421               || (real_identical (&re_mode, &re)
9422                   && real_identical (&im_mode, &im)))
9423             return build_complex (type, build_real (TREE_TYPE (type), re_mode),
9424                                   build_real (TREE_TYPE (type), im_mode));
9425         }
9426     }
9427   return NULL_TREE;
9428 }
9429
9430 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
9431    the pointer *(ARG_QUO) and return the result.  The type is taken
9432    from the type of ARG0 and is used for setting the precision of the
9433    calculation and results.  */
9434
9435 static tree
9436 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
9437 {
9438   tree const type = TREE_TYPE (arg0);
9439   tree result = NULL_TREE;
9440
9441   STRIP_NOPS (arg0);
9442   STRIP_NOPS (arg1);
9443
9444   /* To proceed, MPFR must exactly represent the target floating point
9445      format, which only happens when the target base equals two.  */
9446   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
9447       && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9448       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
9449     {
9450       const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
9451       const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
9452
9453       if (real_isfinite (ra0) && real_isfinite (ra1))
9454         {
9455           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
9456           const int prec = fmt->p;
9457           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
9458           tree result_rem;
9459           long integer_quo;
9460           mpfr_t m0, m1;
9461
9462           mpfr_inits2 (prec, m0, m1, NULL);
9463           mpfr_from_real (m0, ra0, GMP_RNDN);
9464           mpfr_from_real (m1, ra1, GMP_RNDN);
9465           mpfr_clear_flags ();
9466           mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
9467           /* Remquo is independent of the rounding mode, so pass
9468              inexact=0 to do_mpfr_ckconv().  */
9469           result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
9470           mpfr_clears (m0, m1, NULL);
9471           if (result_rem)
9472             {
9473               /* MPFR calculates quo in the host's long so it may
9474                  return more bits in quo than the target int can hold
9475                  if sizeof(host long) > sizeof(target int).  This can
9476                  happen even for native compilers in LP64 mode.  In
9477                  these cases, modulo the quo value with the largest
9478                  number that the target int can hold while leaving one
9479                  bit for the sign.  */
9480               if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
9481                 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
9482
9483               /* Dereference the quo pointer argument.  */
9484               arg_quo = build_fold_indirect_ref (arg_quo);
9485               /* Proceed iff a valid pointer type was passed in.  */
9486               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
9487                 {
9488                   /* Set the value. */
9489                   tree result_quo
9490                     = fold_build2 (MODIFY_EXPR, TREE_TYPE (arg_quo), arg_quo,
9491                                    build_int_cst (TREE_TYPE (arg_quo),
9492                                                   integer_quo));
9493                   TREE_SIDE_EFFECTS (result_quo) = 1;
9494                   /* Combine the quo assignment with the rem.  */
9495                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
9496                                                     result_quo, result_rem));
9497                 }
9498             }
9499         }
9500     }
9501   return result;
9502 }
9503
9504 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
9505    resulting value as a tree with type TYPE.  The mpfr precision is
9506    set to the precision of TYPE.  We assume that this mpfr function
9507    returns zero if the result could be calculated exactly within the
9508    requested precision.  In addition, the integer pointer represented
9509    by ARG_SG will be dereferenced and set to the appropriate signgam
9510    (-1,1) value.  */
9511
9512 static tree
9513 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
9514 {
9515   tree result = NULL_TREE;
9516
9517   STRIP_NOPS (arg);
9518
9519   /* To proceed, MPFR must exactly represent the target floating point
9520      format, which only happens when the target base equals two.  Also
9521      verify ARG is a constant and that ARG_SG is an int pointer.  */
9522   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
9523       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
9524       && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
9525       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
9526     {
9527       const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
9528
9529       /* In addition to NaN and Inf, the argument cannot be zero or a
9530          negative integer.  */
9531       if (real_isfinite (ra)
9532           && ra->cl != rvc_zero
9533           && !(real_isneg (ra) && real_isinteger (ra, TYPE_MODE (type))))
9534         {
9535           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
9536           const int prec = fmt->p;
9537           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
9538           int inexact, sg;
9539           mpfr_t m;
9540           tree result_lg;
9541
9542           mpfr_init2 (m, prec);
9543           mpfr_from_real (m, ra, GMP_RNDN);
9544           mpfr_clear_flags ();
9545           inexact = mpfr_lgamma (m, &sg, m, rnd);
9546           result_lg = do_mpfr_ckconv (m, type, inexact);
9547           mpfr_clear (m);
9548           if (result_lg)
9549             {
9550               tree result_sg;
9551
9552               /* Dereference the arg_sg pointer argument.  */
9553               arg_sg = build_fold_indirect_ref (arg_sg);
9554               /* Assign the signgam value into *arg_sg. */
9555               result_sg = fold_build2 (MODIFY_EXPR,
9556                                        TREE_TYPE (arg_sg), arg_sg,
9557                                        build_int_cst (TREE_TYPE (arg_sg), sg));
9558               TREE_SIDE_EFFECTS (result_sg) = 1;
9559               /* Combine the signgam assignment with the lgamma result.  */
9560               result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
9561                                                 result_sg, result_lg));
9562             }
9563         }
9564     }
9565
9566   return result;
9567 }
9568
9569 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
9570    mpc function FUNC on it and return the resulting value as a tree
9571    with type TYPE.  The mpfr precision is set to the precision of
9572    TYPE.  We assume that function FUNC returns zero if the result
9573    could be calculated exactly within the requested precision.  If
9574    DO_NONFINITE is true, then fold expressions containing Inf or NaN
9575    in the arguments and/or results.  */
9576
9577 tree
9578 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
9579              int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
9580 {
9581   tree result = NULL_TREE;
9582
9583   STRIP_NOPS (arg0);
9584   STRIP_NOPS (arg1);
9585
9586   /* To proceed, MPFR must exactly represent the target floating point
9587      format, which only happens when the target base equals two.  */
9588   if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
9589       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
9590       && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
9591       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
9592       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
9593     {
9594       const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
9595       const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
9596       const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
9597       const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
9598
9599       if (do_nonfinite
9600           || (real_isfinite (re0) && real_isfinite (im0)
9601               && real_isfinite (re1) && real_isfinite (im1)))
9602         {
9603           const struct real_format *const fmt =
9604             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
9605           const int prec = fmt->p;
9606           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
9607           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
9608           int inexact;
9609           mpc_t m0, m1;
9610
9611           mpc_init2 (m0, prec);
9612           mpc_init2 (m1, prec);
9613           mpfr_from_real (mpc_realref (m0), re0, rnd);
9614           mpfr_from_real (mpc_imagref (m0), im0, rnd);
9615           mpfr_from_real (mpc_realref (m1), re1, rnd);
9616           mpfr_from_real (mpc_imagref (m1), im1, rnd);
9617           mpfr_clear_flags ();
9618           inexact = func (m0, m0, m1, crnd);
9619           result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
9620           mpc_clear (m0);
9621           mpc_clear (m1);
9622         }
9623     }
9624
9625   return result;
9626 }
9627
9628 /* A wrapper function for builtin folding that prevents warnings for
9629    "statement without effect" and the like, caused by removing the
9630    call node earlier than the warning is generated.  */
9631
9632 tree
9633 fold_call_stmt (gcall *stmt, bool ignore)
9634 {
9635   tree ret = NULL_TREE;
9636   tree fndecl = gimple_call_fndecl (stmt);
9637   location_t loc = gimple_location (stmt);
9638   if (fndecl
9639       && TREE_CODE (fndecl) == FUNCTION_DECL
9640       && DECL_BUILT_IN (fndecl)
9641       && !gimple_call_va_arg_pack_p (stmt))
9642     {
9643       int nargs = gimple_call_num_args (stmt);
9644       tree *args = (nargs > 0
9645                     ? gimple_call_arg_ptr (stmt, 0)
9646                     : &error_mark_node);
9647
9648       if (avoid_folding_inline_builtin (fndecl))
9649         return NULL_TREE;
9650       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
9651         {
9652           return targetm.fold_builtin (fndecl, nargs, args, ignore);
9653         }
9654       else
9655         {
9656           ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
9657           if (ret)
9658             {
9659               /* Propagate location information from original call to
9660                  expansion of builtin.  Otherwise things like
9661                  maybe_emit_chk_warning, that operate on the expansion
9662                  of a builtin, will use the wrong location information.  */
9663               if (gimple_has_location (stmt))
9664                 {
9665                   tree realret = ret;
9666                   if (TREE_CODE (ret) == NOP_EXPR)
9667                     realret = TREE_OPERAND (ret, 0);
9668                   if (CAN_HAVE_LOCATION_P (realret)
9669                       && !EXPR_HAS_LOCATION (realret))
9670                     SET_EXPR_LOCATION (realret, loc);
9671                   return realret;
9672                 }
9673               return ret;
9674             }
9675         }
9676     }
9677   return NULL_TREE;
9678 }
9679
9680 /* Look up the function in builtin_decl that corresponds to DECL
9681    and set ASMSPEC as its user assembler name.  DECL must be a
9682    function decl that declares a builtin.  */
9683
9684 void
9685 set_builtin_user_assembler_name (tree decl, const char *asmspec)
9686 {
9687   tree builtin;
9688   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
9689               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
9690               && asmspec != 0);
9691
9692   builtin = builtin_decl_explicit (DECL_FUNCTION_CODE (decl));
9693   set_user_assembler_name (builtin, asmspec);
9694   switch (DECL_FUNCTION_CODE (decl))
9695     {
9696     case BUILT_IN_MEMCPY:
9697       init_block_move_fn (asmspec);
9698       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
9699       break;
9700     case BUILT_IN_MEMSET:
9701       init_block_clear_fn (asmspec);
9702       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
9703       break;
9704     case BUILT_IN_MEMMOVE:
9705       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
9706       break;
9707     case BUILT_IN_MEMCMP:
9708       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
9709       break;
9710     case BUILT_IN_ABORT:
9711       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
9712       break;
9713     case BUILT_IN_FFS:
9714       if (INT_TYPE_SIZE < BITS_PER_WORD)
9715         {
9716           set_user_assembler_libfunc ("ffs", asmspec);
9717           set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
9718                                                        MODE_INT, 0), "ffs");
9719         }
9720       break;
9721     default:
9722       break;
9723     }
9724 }
9725
9726 /* Return true if DECL is a builtin that expands to a constant or similarly
9727    simple code.  */
9728 bool
9729 is_simple_builtin (tree decl)
9730 {
9731   if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
9732     switch (DECL_FUNCTION_CODE (decl))
9733       {
9734         /* Builtins that expand to constants.  */
9735       case BUILT_IN_CONSTANT_P:
9736       case BUILT_IN_EXPECT:
9737       case BUILT_IN_OBJECT_SIZE:
9738       case BUILT_IN_UNREACHABLE:
9739         /* Simple register moves or loads from stack.  */
9740       case BUILT_IN_ASSUME_ALIGNED:
9741       case BUILT_IN_RETURN_ADDRESS:
9742       case BUILT_IN_EXTRACT_RETURN_ADDR:
9743       case BUILT_IN_FROB_RETURN_ADDR:
9744       case BUILT_IN_RETURN:
9745       case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
9746       case BUILT_IN_FRAME_ADDRESS:
9747       case BUILT_IN_VA_END:
9748       case BUILT_IN_STACK_SAVE:
9749       case BUILT_IN_STACK_RESTORE:
9750         /* Exception state returns or moves registers around.  */
9751       case BUILT_IN_EH_FILTER:
9752       case BUILT_IN_EH_POINTER:
9753       case BUILT_IN_EH_COPY_VALUES:
9754         return true;
9755
9756       default:
9757         return false;
9758       }
9759
9760   return false;
9761 }
9762
9763 /* Return true if DECL is a builtin that is not expensive, i.e., they are
9764    most probably expanded inline into reasonably simple code.  This is a
9765    superset of is_simple_builtin.  */
9766 bool
9767 is_inexpensive_builtin (tree decl)
9768 {
9769   if (!decl)
9770     return false;
9771   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
9772     return true;
9773   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
9774     switch (DECL_FUNCTION_CODE (decl))
9775       {
9776       case BUILT_IN_ABS:
9777       case BUILT_IN_ALLOCA:
9778       case BUILT_IN_ALLOCA_WITH_ALIGN:
9779       case BUILT_IN_BSWAP16:
9780       case BUILT_IN_BSWAP32:
9781       case BUILT_IN_BSWAP64:
9782       case BUILT_IN_CLZ:
9783       case BUILT_IN_CLZIMAX:
9784       case BUILT_IN_CLZL:
9785       case BUILT_IN_CLZLL:
9786       case BUILT_IN_CTZ:
9787       case BUILT_IN_CTZIMAX:
9788       case BUILT_IN_CTZL:
9789       case BUILT_IN_CTZLL:
9790       case BUILT_IN_FFS:
9791       case BUILT_IN_FFSIMAX:
9792       case BUILT_IN_FFSL:
9793       case BUILT_IN_FFSLL:
9794       case BUILT_IN_IMAXABS:
9795       case BUILT_IN_FINITE:
9796       case BUILT_IN_FINITEF:
9797       case BUILT_IN_FINITEL:
9798       case BUILT_IN_FINITED32:
9799       case BUILT_IN_FINITED64:
9800       case BUILT_IN_FINITED128:
9801       case BUILT_IN_FPCLASSIFY:
9802       case BUILT_IN_ISFINITE:
9803       case BUILT_IN_ISINF_SIGN:
9804       case BUILT_IN_ISINF:
9805       case BUILT_IN_ISINFF:
9806       case BUILT_IN_ISINFL:
9807       case BUILT_IN_ISINFD32:
9808       case BUILT_IN_ISINFD64:
9809       case BUILT_IN_ISINFD128:
9810       case BUILT_IN_ISNAN:
9811       case BUILT_IN_ISNANF:
9812       case BUILT_IN_ISNANL:
9813       case BUILT_IN_ISNAND32:
9814       case BUILT_IN_ISNAND64:
9815       case BUILT_IN_ISNAND128:
9816       case BUILT_IN_ISNORMAL:
9817       case BUILT_IN_ISGREATER:
9818       case BUILT_IN_ISGREATEREQUAL:
9819       case BUILT_IN_ISLESS:
9820       case BUILT_IN_ISLESSEQUAL:
9821       case BUILT_IN_ISLESSGREATER:
9822       case BUILT_IN_ISUNORDERED:
9823       case BUILT_IN_VA_ARG_PACK:
9824       case BUILT_IN_VA_ARG_PACK_LEN:
9825       case BUILT_IN_VA_COPY:
9826       case BUILT_IN_TRAP:
9827       case BUILT_IN_SAVEREGS:
9828       case BUILT_IN_POPCOUNTL:
9829       case BUILT_IN_POPCOUNTLL:
9830       case BUILT_IN_POPCOUNTIMAX:
9831       case BUILT_IN_POPCOUNT:
9832       case BUILT_IN_PARITYL:
9833       case BUILT_IN_PARITYLL:
9834       case BUILT_IN_PARITYIMAX:
9835       case BUILT_IN_PARITY:
9836       case BUILT_IN_LABS:
9837       case BUILT_IN_LLABS:
9838       case BUILT_IN_PREFETCH:
9839       case BUILT_IN_ACC_ON_DEVICE:
9840         return true;
9841
9842       default:
9843         return is_simple_builtin (decl);
9844       }
9845
9846   return false;
9847 }