gcc/builtins.c

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