gcc/builtins.c

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