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       || !CALL_EXPR_FN (t)
6775       || TREE_CODE (CALL_EXPR_FN (t)) != ADDR_EXPR)
6776     return END_BUILTINS;
6777
6778   fndecl = get_callee_fndecl (t);
6779   if (fndecl == NULL_TREE
6780       || TREE_CODE (fndecl) != FUNCTION_DECL
6781       || ! DECL_BUILT_IN (fndecl)
6782       || DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
6783     return END_BUILTINS;
6784
6785   parmlist = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
6786   init_const_call_expr_arg_iterator (t, &iter);
6787   for (; parmlist; parmlist = TREE_CHAIN (parmlist))
6788     {
6789       /* If a function doesn't take a variable number of arguments,
6790          the last element in the list will have type `void'.  */
6791       parmtype = TREE_VALUE (parmlist);
6792       if (VOID_TYPE_P (parmtype))
6793         {
6794           if (more_const_call_expr_args_p (&iter))
6795             return END_BUILTINS;
6796           return DECL_FUNCTION_CODE (fndecl);
6797         }
6798
6799       if (! more_const_call_expr_args_p (&iter))
6800         return END_BUILTINS;
6801
6802       arg = next_const_call_expr_arg (&iter);
6803       argtype = TREE_TYPE (arg);
6804
6805       if (SCALAR_FLOAT_TYPE_P (parmtype))
6806         {
6807           if (! SCALAR_FLOAT_TYPE_P (argtype))
6808             return END_BUILTINS;
6809         }
6810       else if (COMPLEX_FLOAT_TYPE_P (parmtype))
6811         {
6812           if (! COMPLEX_FLOAT_TYPE_P (argtype))
6813             return END_BUILTINS;
6814         }
6815       else if (POINTER_TYPE_P (parmtype))
6816         {
6817           if (! POINTER_TYPE_P (argtype))
6818             return END_BUILTINS;
6819         }
6820       else if (INTEGRAL_TYPE_P (parmtype))
6821         {
6822           if (! INTEGRAL_TYPE_P (argtype))
6823             return END_BUILTINS;
6824         }
6825       else
6826         return END_BUILTINS;
6827     }
6828
6829   /* Variable-length argument list.  */
6830   return DECL_FUNCTION_CODE (fndecl);
6831 }
6832
6833 /* Fold a call to __builtin_constant_p, if we know its argument ARG will
6834    evaluate to a constant.  */
6835
6836 static tree
6837 fold_builtin_constant_p (tree arg)
6838 {
6839   /* We return 1 for a numeric type that's known to be a constant
6840      value at compile-time or for an aggregate type that's a
6841      literal constant.  */
6842   STRIP_NOPS (arg);
6843
6844   /* If we know this is a constant, emit the constant of one.  */
6845   if (CONSTANT_CLASS_P (arg)
6846       || (TREE_CODE (arg) == CONSTRUCTOR
6847           && TREE_CONSTANT (arg)))
6848     return integer_one_node;
6849   if (TREE_CODE (arg) == ADDR_EXPR)
6850     {
6851        tree op = TREE_OPERAND (arg, 0);
6852        if (TREE_CODE (op) == STRING_CST
6853            || (TREE_CODE (op) == ARRAY_REF
6854                && integer_zerop (TREE_OPERAND (op, 1))
6855                && TREE_CODE (TREE_OPERAND (op, 0)) == STRING_CST))
6856          return integer_one_node;
6857     }
6858
6859   /* If this expression has side effects, show we don't know it to be a
6860      constant.  Likewise if it's a pointer or aggregate type since in
6861      those case we only want literals, since those are only optimized
6862      when generating RTL, not later.
6863      And finally, if we are compiling an initializer, not code, we
6864      need to return a definite result now; there's not going to be any
6865      more optimization done.  */
6866   if (TREE_SIDE_EFFECTS (arg)
6867       || AGGREGATE_TYPE_P (TREE_TYPE (arg))
6868       || POINTER_TYPE_P (TREE_TYPE (arg))
6869       || cfun == 0
6870       || folding_initializer
6871       || force_folding_builtin_constant_p)
6872     return integer_zero_node;
6873
6874   return NULL_TREE;
6875 }
6876
6877 /* Create builtin_expect with PRED and EXPECTED as its arguments and
6878    return it as a truthvalue.  */
6879
6880 static tree
6881 build_builtin_expect_predicate (location_t loc, tree pred, tree expected,
6882                                 tree predictor)
6883 {
6884   tree fn, arg_types, pred_type, expected_type, call_expr, ret_type;
6885
6886   fn = builtin_decl_explicit (BUILT_IN_EXPECT);
6887   arg_types = TYPE_ARG_TYPES (TREE_TYPE (fn));
6888   ret_type = TREE_TYPE (TREE_TYPE (fn));
6889   pred_type = TREE_VALUE (arg_types);
6890   expected_type = TREE_VALUE (TREE_CHAIN (arg_types));
6891
6892   pred = fold_convert_loc (loc, pred_type, pred);
6893   expected = fold_convert_loc (loc, expected_type, expected);
6894   call_expr = build_call_expr_loc (loc, fn, predictor ? 3 : 2, pred, expected,
6895                                    predictor);
6896
6897   return build2 (NE_EXPR, TREE_TYPE (pred), call_expr,
6898                  build_int_cst (ret_type, 0));
6899 }
6900
6901 /* Fold a call to builtin_expect with arguments ARG0 and ARG1.  Return
6902    NULL_TREE if no simplification is possible.  */
6903
6904 tree
6905 fold_builtin_expect (location_t loc, tree arg0, tree arg1, tree arg2)
6906 {
6907   tree inner, fndecl, inner_arg0;
6908   enum tree_code code;
6909
6910   /* Distribute the expected value over short-circuiting operators.
6911      See through the cast from truthvalue_type_node to long.  */
6912   inner_arg0 = arg0;
6913   while (CONVERT_EXPR_P (inner_arg0)
6914          && INTEGRAL_TYPE_P (TREE_TYPE (inner_arg0))
6915          && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (inner_arg0, 0))))
6916     inner_arg0 = TREE_OPERAND (inner_arg0, 0);
6917
6918   /* If this is a builtin_expect within a builtin_expect keep the
6919      inner one.  See through a comparison against a constant.  It
6920      might have been added to create a thruthvalue.  */
6921   inner = inner_arg0;
6922
6923   if (COMPARISON_CLASS_P (inner)
6924       && TREE_CODE (TREE_OPERAND (inner, 1)) == INTEGER_CST)
6925     inner = TREE_OPERAND (inner, 0);
6926
6927   if (TREE_CODE (inner) == CALL_EXPR
6928       && (fndecl = get_callee_fndecl (inner))
6929       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
6930       && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_EXPECT)
6931     return arg0;
6932
6933   inner = inner_arg0;
6934   code = TREE_CODE (inner);
6935   if (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)
6936     {
6937       tree op0 = TREE_OPERAND (inner, 0);
6938       tree op1 = TREE_OPERAND (inner, 1);
6939
6940       op0 = build_builtin_expect_predicate (loc, op0, arg1, arg2);
6941       op1 = build_builtin_expect_predicate (loc, op1, arg1, arg2);
6942       inner = build2 (code, TREE_TYPE (inner), op0, op1);
6943
6944       return fold_convert_loc (loc, TREE_TYPE (arg0), inner);
6945     }
6946
6947   /* If the argument isn't invariant then there's nothing else we can do.  */
6948   if (!TREE_CONSTANT (inner_arg0))
6949     return NULL_TREE;
6950
6951   /* If we expect that a comparison against the argument will fold to
6952      a constant return the constant.  In practice, this means a true
6953      constant or the address of a non-weak symbol.  */
6954   inner = inner_arg0;
6955   STRIP_NOPS (inner);
6956   if (TREE_CODE (inner) == ADDR_EXPR)
6957     {
6958       do
6959         {
6960           inner = TREE_OPERAND (inner, 0);
6961         }
6962       while (TREE_CODE (inner) == COMPONENT_REF
6963              || TREE_CODE (inner) == ARRAY_REF);
6964       if ((TREE_CODE (inner) == VAR_DECL
6965            || TREE_CODE (inner) == FUNCTION_DECL)
6966           && DECL_WEAK (inner))
6967         return NULL_TREE;
6968     }
6969
6970   /* Otherwise, ARG0 already has the proper type for the return value.  */
6971   return arg0;
6972 }
6973
6974 /* Fold a call to __builtin_classify_type with argument ARG.  */
6975
6976 static tree
6977 fold_builtin_classify_type (tree arg)
6978 {
6979   if (arg == 0)
6980     return build_int_cst (integer_type_node, no_type_class);
6981
6982   return build_int_cst (integer_type_node, type_to_class (TREE_TYPE (arg)));
6983 }
6984
6985 /* Fold a call to __builtin_strlen with argument ARG.  */
6986
6987 static tree
6988 fold_builtin_strlen (location_t loc, tree type, tree arg)
6989 {
6990   if (!validate_arg (arg, POINTER_TYPE))
6991     return NULL_TREE;
6992   else
6993     {
6994       tree len = c_strlen (arg, 0);
6995
6996       if (len)
6997         return fold_convert_loc (loc, type, len);
6998
6999       return NULL_TREE;
7000     }
7001 }
7002
7003 /* Fold a call to __builtin_inf or __builtin_huge_val.  */
7004
7005 static tree
7006 fold_builtin_inf (location_t loc, tree type, int warn)
7007 {
7008   REAL_VALUE_TYPE real;
7009
7010   /* __builtin_inff is intended to be usable to define INFINITY on all
7011      targets.  If an infinity is not available, INFINITY expands "to a
7012      positive constant of type float that overflows at translation
7013      time", footnote "In this case, using INFINITY will violate the
7014      constraint in 6.4.4 and thus require a diagnostic." (C99 7.12#4).
7015      Thus we pedwarn to ensure this constraint violation is
7016      diagnosed.  */
7017   if (!MODE_HAS_INFINITIES (TYPE_MODE (type)) && warn)
7018     pedwarn (loc, 0, "target format does not support infinity");
7019
7020   real_inf (&real);
7021   return build_real (type, real);
7022 }
7023
7024 /* Fold function call to builtin sincos, sincosf, or sincosl.  Return
7025    NULL_TREE if no simplification can be made.  */
7026
7027 static tree
7028 fold_builtin_sincos (location_t loc,
7029                      tree arg0, tree arg1, tree arg2)
7030 {
7031   tree type;
7032   tree fndecl, call = NULL_TREE;
7033
7034   if (!validate_arg (arg0, REAL_TYPE)
7035       || !validate_arg (arg1, POINTER_TYPE)
7036       || !validate_arg (arg2, POINTER_TYPE))
7037     return NULL_TREE;
7038
7039   type = TREE_TYPE (arg0);
7040
7041   /* Calculate the result when the argument is a constant.  */
7042   built_in_function fn = mathfn_built_in_2 (type, CFN_BUILT_IN_CEXPI);
7043   if (fn == END_BUILTINS)
7044     return NULL_TREE;
7045
7046   /* Canonicalize sincos to cexpi.  */
7047   if (TREE_CODE (arg0) == REAL_CST)
7048     {
7049       tree complex_type = build_complex_type (type);
7050       call = fold_const_call (as_combined_fn (fn), complex_type, arg0);
7051     }
7052   if (!call)
7053     {
7054       if (!targetm.libc_has_function (function_c99_math_complex)
7055           || !builtin_decl_implicit_p (fn))
7056         return NULL_TREE;
7057       fndecl = builtin_decl_explicit (fn);
7058       call = build_call_expr_loc (loc, fndecl, 1, arg0);
7059       call = builtin_save_expr (call);
7060     }
7061
7062   return build2 (COMPOUND_EXPR, void_type_node,
7063                  build2 (MODIFY_EXPR, void_type_node,
7064                          build_fold_indirect_ref_loc (loc, arg1),
7065                          fold_build1_loc (loc, IMAGPART_EXPR, type, call)),
7066                  build2 (MODIFY_EXPR, void_type_node,
7067                          build_fold_indirect_ref_loc (loc, arg2),
7068                          fold_build1_loc (loc, REALPART_EXPR, type, call)));
7069 }
7070
7071 /* Fold function call to builtin memchr.  ARG1, ARG2 and LEN are the
7072    arguments to the call, and TYPE is its return type.
7073    Return NULL_TREE if no simplification can be made.  */
7074
7075 static tree
7076 fold_builtin_memchr (location_t loc, tree arg1, tree arg2, tree len, tree type)
7077 {
7078   if (!validate_arg (arg1, POINTER_TYPE)
7079       || !validate_arg (arg2, INTEGER_TYPE)
7080       || !validate_arg (len, INTEGER_TYPE))
7081     return NULL_TREE;
7082   else
7083     {
7084       const char *p1;
7085
7086       if (TREE_CODE (arg2) != INTEGER_CST
7087           || !tree_fits_uhwi_p (len))
7088         return NULL_TREE;
7089
7090       p1 = c_getstr (arg1);
7091       if (p1 && compare_tree_int (len, strlen (p1) + 1) <= 0)
7092         {
7093           char c;
7094           const char *r;
7095           tree tem;
7096
7097           if (target_char_cast (arg2, &c))
7098             return NULL_TREE;
7099
7100           r = (const char *) memchr (p1, c, tree_to_uhwi (len));
7101
7102           if (r == NULL)
7103             return build_int_cst (TREE_TYPE (arg1), 0);
7104
7105           tem = fold_build_pointer_plus_hwi_loc (loc, arg1, r - p1);
7106           return fold_convert_loc (loc, type, tem);
7107         }
7108       return NULL_TREE;
7109     }
7110 }
7111
7112 /* Fold function call to builtin memcmp with arguments ARG1 and ARG2.
7113    Return NULL_TREE if no simplification can be made.  */
7114
7115 static tree
7116 fold_builtin_memcmp (location_t loc, tree arg1, tree arg2, tree len)
7117 {
7118   if (!validate_arg (arg1, POINTER_TYPE)
7119       || !validate_arg (arg2, POINTER_TYPE)
7120       || !validate_arg (len, INTEGER_TYPE))
7121     return NULL_TREE;
7122
7123   /* If the LEN parameter is zero, return zero.  */
7124   if (integer_zerop (len))
7125     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
7126                               arg1, arg2);
7127
7128   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
7129   if (operand_equal_p (arg1, arg2, 0))
7130     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
7131
7132   /* If len parameter is one, return an expression corresponding to
7133      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
7134   if (tree_fits_uhwi_p (len) && tree_to_uhwi (len) == 1)
7135     {
7136       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7137       tree cst_uchar_ptr_node
7138         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7139
7140       tree ind1
7141         = fold_convert_loc (loc, integer_type_node,
7142                             build1 (INDIRECT_REF, cst_uchar_node,
7143                                     fold_convert_loc (loc,
7144                                                       cst_uchar_ptr_node,
7145                                                       arg1)));
7146       tree ind2
7147         = fold_convert_loc (loc, integer_type_node,
7148                             build1 (INDIRECT_REF, cst_uchar_node,
7149                                     fold_convert_loc (loc,
7150                                                       cst_uchar_ptr_node,
7151                                                       arg2)));
7152       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
7153     }
7154
7155   return NULL_TREE;
7156 }
7157
7158 /* Fold function call to builtin strcmp with arguments ARG1 and ARG2.
7159    Return NULL_TREE if no simplification can be made.  */
7160
7161 static tree
7162 fold_builtin_strcmp (location_t loc, tree arg1, tree arg2)
7163 {
7164   if (!validate_arg (arg1, POINTER_TYPE)
7165       || !validate_arg (arg2, POINTER_TYPE))
7166     return NULL_TREE;
7167
7168   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
7169   if (operand_equal_p (arg1, arg2, 0))
7170     return integer_zero_node;
7171
7172   /* If the second arg is "", return *(const unsigned char*)arg1.  */
7173   const char *p2 = c_getstr (arg2);
7174   if (p2 && *p2 == '\0')
7175     {
7176       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7177       tree cst_uchar_ptr_node
7178         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7179
7180       return fold_convert_loc (loc, integer_type_node,
7181                                build1 (INDIRECT_REF, cst_uchar_node,
7182                                        fold_convert_loc (loc,
7183                                                          cst_uchar_ptr_node,
7184                                                          arg1)));
7185     }
7186
7187   /* If the first arg is "", return -*(const unsigned char*)arg2.  */
7188   const char *p1 = c_getstr (arg1);
7189   if (p1 && *p1 == '\0')
7190     {
7191       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7192       tree cst_uchar_ptr_node
7193         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7194
7195       tree temp
7196         = fold_convert_loc (loc, integer_type_node,
7197                             build1 (INDIRECT_REF, cst_uchar_node,
7198                                     fold_convert_loc (loc,
7199                                                       cst_uchar_ptr_node,
7200                                                       arg2)));
7201       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
7202     }
7203
7204   return NULL_TREE;
7205 }
7206
7207 /* Fold function call to builtin strncmp with arguments ARG1, ARG2, and LEN.
7208    Return NULL_TREE if no simplification can be made.  */
7209
7210 static tree
7211 fold_builtin_strncmp (location_t loc, tree arg1, tree arg2, tree len)
7212 {
7213   if (!validate_arg (arg1, POINTER_TYPE)
7214       || !validate_arg (arg2, POINTER_TYPE)
7215       || !validate_arg (len, INTEGER_TYPE))
7216     return NULL_TREE;
7217
7218   /* If the LEN parameter is zero, return zero.  */
7219   if (integer_zerop (len))
7220     return omit_two_operands_loc (loc, integer_type_node, integer_zero_node,
7221                               arg1, arg2);
7222
7223   /* If ARG1 and ARG2 are the same (and not volatile), return zero.  */
7224   if (operand_equal_p (arg1, arg2, 0))
7225     return omit_one_operand_loc (loc, integer_type_node, integer_zero_node, len);
7226
7227   /* If the second arg is "", and the length is greater than zero,
7228      return *(const unsigned char*)arg1.  */
7229   const char *p2 = c_getstr (arg2);
7230   if (p2 && *p2 == '\0'
7231       && TREE_CODE (len) == INTEGER_CST
7232       && tree_int_cst_sgn (len) == 1)
7233     {
7234       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7235       tree cst_uchar_ptr_node
7236         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7237
7238       return fold_convert_loc (loc, integer_type_node,
7239                                build1 (INDIRECT_REF, cst_uchar_node,
7240                                        fold_convert_loc (loc,
7241                                                          cst_uchar_ptr_node,
7242                                                          arg1)));
7243     }
7244
7245   /* If the first arg is "", and the length is greater than zero,
7246      return -*(const unsigned char*)arg2.  */
7247   const char *p1 = c_getstr (arg1);
7248   if (p1 && *p1 == '\0'
7249       && TREE_CODE (len) == INTEGER_CST
7250       && tree_int_cst_sgn (len) == 1)
7251     {
7252       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7253       tree cst_uchar_ptr_node
7254         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7255
7256       tree temp = fold_convert_loc (loc, integer_type_node,
7257                                     build1 (INDIRECT_REF, cst_uchar_node,
7258                                             fold_convert_loc (loc,
7259                                                               cst_uchar_ptr_node,
7260                                                               arg2)));
7261       return fold_build1_loc (loc, NEGATE_EXPR, integer_type_node, temp);
7262     }
7263
7264   /* If len parameter is one, return an expression corresponding to
7265      (*(const unsigned char*)arg1 - (const unsigned char*)arg2).  */
7266   if (tree_fits_uhwi_p (len) && tree_to_uhwi (len) == 1)
7267     {
7268       tree cst_uchar_node = build_type_variant (unsigned_char_type_node, 1, 0);
7269       tree cst_uchar_ptr_node
7270         = build_pointer_type_for_mode (cst_uchar_node, ptr_mode, true);
7271
7272       tree ind1 = fold_convert_loc (loc, integer_type_node,
7273                                     build1 (INDIRECT_REF, cst_uchar_node,
7274                                             fold_convert_loc (loc,
7275                                                               cst_uchar_ptr_node,
7276                                                               arg1)));
7277       tree ind2 = fold_convert_loc (loc, integer_type_node,
7278                                     build1 (INDIRECT_REF, cst_uchar_node,
7279                                             fold_convert_loc (loc,
7280                                                               cst_uchar_ptr_node,
7281                                                               arg2)));
7282       return fold_build2_loc (loc, MINUS_EXPR, integer_type_node, ind1, ind2);
7283     }
7284
7285   return NULL_TREE;
7286 }
7287
7288 /* Fold a call to builtin isascii with argument ARG.  */
7289
7290 static tree
7291 fold_builtin_isascii (location_t loc, tree arg)
7292 {
7293   if (!validate_arg (arg, INTEGER_TYPE))
7294     return NULL_TREE;
7295   else
7296     {
7297       /* Transform isascii(c) -> ((c & ~0x7f) == 0).  */
7298       arg = fold_build2 (BIT_AND_EXPR, integer_type_node, arg,
7299                          build_int_cst (integer_type_node,
7300                                         ~ (unsigned HOST_WIDE_INT) 0x7f));
7301       return fold_build2_loc (loc, EQ_EXPR, integer_type_node,
7302                               arg, integer_zero_node);
7303     }
7304 }
7305
7306 /* Fold a call to builtin toascii with argument ARG.  */
7307
7308 static tree
7309 fold_builtin_toascii (location_t loc, tree arg)
7310 {
7311   if (!validate_arg (arg, INTEGER_TYPE))
7312     return NULL_TREE;
7313
7314   /* Transform toascii(c) -> (c & 0x7f).  */
7315   return fold_build2_loc (loc, BIT_AND_EXPR, integer_type_node, arg,
7316                           build_int_cst (integer_type_node, 0x7f));
7317 }
7318
7319 /* Fold a call to builtin isdigit with argument ARG.  */
7320
7321 static tree
7322 fold_builtin_isdigit (location_t loc, tree arg)
7323 {
7324   if (!validate_arg (arg, INTEGER_TYPE))
7325     return NULL_TREE;
7326   else
7327     {
7328       /* Transform isdigit(c) -> (unsigned)(c) - '0' <= 9.  */
7329       /* According to the C standard, isdigit is unaffected by locale.
7330          However, it definitely is affected by the target character set.  */
7331       unsigned HOST_WIDE_INT target_digit0
7332         = lang_hooks.to_target_charset ('0');
7333
7334       if (target_digit0 == 0)
7335         return NULL_TREE;
7336
7337       arg = fold_convert_loc (loc, unsigned_type_node, arg);
7338       arg = fold_build2 (MINUS_EXPR, unsigned_type_node, arg,
7339                          build_int_cst (unsigned_type_node, target_digit0));
7340       return fold_build2_loc (loc, LE_EXPR, integer_type_node, arg,
7341                           build_int_cst (unsigned_type_node, 9));
7342     }
7343 }
7344
7345 /* Fold a call to fabs, fabsf or fabsl with argument ARG.  */
7346
7347 static tree
7348 fold_builtin_fabs (location_t loc, tree arg, tree type)
7349 {
7350   if (!validate_arg (arg, REAL_TYPE))
7351     return NULL_TREE;
7352
7353   arg = fold_convert_loc (loc, type, arg);
7354   return fold_build1_loc (loc, ABS_EXPR, type, arg);
7355 }
7356
7357 /* Fold a call to abs, labs, llabs or imaxabs with argument ARG.  */
7358
7359 static tree
7360 fold_builtin_abs (location_t loc, tree arg, tree type)
7361 {
7362   if (!validate_arg (arg, INTEGER_TYPE))
7363     return NULL_TREE;
7364
7365   arg = fold_convert_loc (loc, type, arg);
7366   return fold_build1_loc (loc, ABS_EXPR, type, arg);
7367 }
7368
7369 /* Fold a call to fma, fmaf, or fmal with arguments ARG[012].  */
7370
7371 static tree
7372 fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type)
7373 {
7374   /* ??? Only expand to FMA_EXPR if it's directly supported.  */
7375   if (validate_arg (arg0, REAL_TYPE)
7376       && validate_arg (arg1, REAL_TYPE)
7377       && validate_arg (arg2, REAL_TYPE)
7378       && optab_handler (fma_optab, TYPE_MODE (type)) != CODE_FOR_nothing)
7379     return fold_build3_loc (loc, FMA_EXPR, type, arg0, arg1, arg2);
7380
7381   return NULL_TREE;
7382 }
7383
7384 /* Fold a call to builtin carg(a+bi) -> atan2(b,a).  */
7385
7386 static tree
7387 fold_builtin_carg (location_t loc, tree arg, tree type)
7388 {
7389   if (validate_arg (arg, COMPLEX_TYPE)
7390       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg))) == REAL_TYPE)
7391     {
7392       tree atan2_fn = mathfn_built_in (type, BUILT_IN_ATAN2);
7393
7394       if (atan2_fn)
7395         {
7396           tree new_arg = builtin_save_expr (arg);
7397           tree r_arg = fold_build1_loc (loc, REALPART_EXPR, type, new_arg);
7398           tree i_arg = fold_build1_loc (loc, IMAGPART_EXPR, type, new_arg);
7399           return build_call_expr_loc (loc, atan2_fn, 2, i_arg, r_arg);
7400         }
7401     }
7402
7403   return NULL_TREE;
7404 }
7405
7406 /* Fold a call to builtin frexp, we can assume the base is 2.  */
7407
7408 static tree
7409 fold_builtin_frexp (location_t loc, tree arg0, tree arg1, tree rettype)
7410 {
7411   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
7412     return NULL_TREE;
7413
7414   STRIP_NOPS (arg0);
7415
7416   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
7417     return NULL_TREE;
7418
7419   arg1 = build_fold_indirect_ref_loc (loc, arg1);
7420
7421   /* Proceed if a valid pointer type was passed in.  */
7422   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == integer_type_node)
7423     {
7424       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
7425       tree frac, exp;
7426
7427       switch (value->cl)
7428       {
7429       case rvc_zero:
7430         /* For +-0, return (*exp = 0, +-0).  */
7431         exp = integer_zero_node;
7432         frac = arg0;
7433         break;
7434       case rvc_nan:
7435       case rvc_inf:
7436         /* For +-NaN or +-Inf, *exp is unspecified, return arg0.  */
7437         return omit_one_operand_loc (loc, rettype, arg0, arg1);
7438       case rvc_normal:
7439         {
7440           /* Since the frexp function always expects base 2, and in
7441              GCC normalized significands are already in the range
7442              [0.5, 1.0), we have exactly what frexp wants.  */
7443           REAL_VALUE_TYPE frac_rvt = *value;
7444           SET_REAL_EXP (&frac_rvt, 0);
7445           frac = build_real (rettype, frac_rvt);
7446           exp = build_int_cst (integer_type_node, REAL_EXP (value));
7447         }
7448         break;
7449       default:
7450         gcc_unreachable ();
7451       }
7452
7453       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
7454       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1, exp);
7455       TREE_SIDE_EFFECTS (arg1) = 1;
7456       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1, frac);
7457     }
7458
7459   return NULL_TREE;
7460 }
7461
7462 /* Fold a call to builtin modf.  */
7463
7464 static tree
7465 fold_builtin_modf (location_t loc, tree arg0, tree arg1, tree rettype)
7466 {
7467   if (! validate_arg (arg0, REAL_TYPE) || ! validate_arg (arg1, POINTER_TYPE))
7468     return NULL_TREE;
7469
7470   STRIP_NOPS (arg0);
7471
7472   if (!(TREE_CODE (arg0) == REAL_CST && ! TREE_OVERFLOW (arg0)))
7473     return NULL_TREE;
7474
7475   arg1 = build_fold_indirect_ref_loc (loc, arg1);
7476
7477   /* Proceed if a valid pointer type was passed in.  */
7478   if (TYPE_MAIN_VARIANT (TREE_TYPE (arg1)) == TYPE_MAIN_VARIANT (rettype))
7479     {
7480       const REAL_VALUE_TYPE *const value = TREE_REAL_CST_PTR (arg0);
7481       REAL_VALUE_TYPE trunc, frac;
7482
7483       switch (value->cl)
7484       {
7485       case rvc_nan:
7486       case rvc_zero:
7487         /* For +-NaN or +-0, return (*arg1 = arg0, arg0).  */
7488         trunc = frac = *value;
7489         break;
7490       case rvc_inf:
7491         /* For +-Inf, return (*arg1 = arg0, +-0).  */
7492         frac = dconst0;
7493         frac.sign = value->sign;
7494         trunc = *value;
7495         break;
7496       case rvc_normal:
7497         /* Return (*arg1 = trunc(arg0), arg0-trunc(arg0)).  */
7498         real_trunc (&trunc, VOIDmode, value);
7499         real_arithmetic (&frac, MINUS_EXPR, value, &trunc);
7500         /* If the original number was negative and already
7501            integral, then the fractional part is -0.0.  */
7502         if (value->sign && frac.cl == rvc_zero)
7503           frac.sign = value->sign;
7504         break;
7505       }
7506
7507       /* Create the COMPOUND_EXPR (*arg1 = trunc, frac). */
7508       arg1 = fold_build2_loc (loc, MODIFY_EXPR, rettype, arg1,
7509                           build_real (rettype, trunc));
7510       TREE_SIDE_EFFECTS (arg1) = 1;
7511       return fold_build2_loc (loc, COMPOUND_EXPR, rettype, arg1,
7512                           build_real (rettype, frac));
7513     }
7514
7515   return NULL_TREE;
7516 }
7517
7518 /* Given a location LOC, an interclass builtin function decl FNDECL
7519    and its single argument ARG, return an folded expression computing
7520    the same, or NULL_TREE if we either couldn't or didn't want to fold
7521    (the latter happen if there's an RTL instruction available).  */
7522
7523 static tree
7524 fold_builtin_interclass_mathfn (location_t loc, tree fndecl, tree arg)
7525 {
7526   machine_mode mode;
7527
7528   if (!validate_arg (arg, REAL_TYPE))
7529     return NULL_TREE;
7530
7531   if (interclass_mathfn_icode (arg, fndecl) != CODE_FOR_nothing)
7532     return NULL_TREE;
7533
7534   mode = TYPE_MODE (TREE_TYPE (arg));
7535
7536   bool is_ibm_extended = MODE_COMPOSITE_P (mode);
7537
7538   /* If there is no optab, try generic code.  */
7539   switch (DECL_FUNCTION_CODE (fndecl))
7540     {
7541       tree result;
7542
7543     CASE_FLT_FN (BUILT_IN_ISINF):
7544       {
7545         /* isinf(x) -> isgreater(fabs(x),DBL_MAX).  */
7546         tree const isgr_fn = builtin_decl_explicit (BUILT_IN_ISGREATER);
7547         tree type = TREE_TYPE (arg);
7548         REAL_VALUE_TYPE r;
7549         char buf[128];
7550
7551         if (is_ibm_extended)
7552           {
7553             /* NaN and Inf are encoded in the high-order double value
7554                only.  The low-order value is not significant.  */
7555             type = double_type_node;
7556             mode = DFmode;
7557             arg = fold_build1_loc (loc, NOP_EXPR, type, arg);
7558           }
7559         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
7560         real_from_string (&r, buf);
7561         result = build_call_expr (isgr_fn, 2,
7562                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
7563                                   build_real (type, r));
7564         return result;
7565       }
7566     CASE_FLT_FN (BUILT_IN_FINITE):
7567     case BUILT_IN_ISFINITE:
7568       {
7569         /* isfinite(x) -> islessequal(fabs(x),DBL_MAX).  */
7570         tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
7571         tree type = TREE_TYPE (arg);
7572         REAL_VALUE_TYPE r;
7573         char buf[128];
7574
7575         if (is_ibm_extended)
7576           {
7577             /* NaN and Inf are encoded in the high-order double value
7578                only.  The low-order value is not significant.  */
7579             type = double_type_node;
7580             mode = DFmode;
7581             arg = fold_build1_loc (loc, NOP_EXPR, type, arg);
7582           }
7583         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
7584         real_from_string (&r, buf);
7585         result = build_call_expr (isle_fn, 2,
7586                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
7587                                   build_real (type, r));
7588         /*result = fold_build2_loc (loc, UNGT_EXPR,
7589                                   TREE_TYPE (TREE_TYPE (fndecl)),
7590                                   fold_build1_loc (loc, ABS_EXPR, type, arg),
7591                                   build_real (type, r));
7592         result = fold_build1_loc (loc, TRUTH_NOT_EXPR,
7593                                   TREE_TYPE (TREE_TYPE (fndecl)),
7594                                   result);*/
7595         return result;
7596       }
7597     case BUILT_IN_ISNORMAL:
7598       {
7599         /* isnormal(x) -> isgreaterequal(fabs(x),DBL_MIN) &
7600            islessequal(fabs(x),DBL_MAX).  */
7601         tree const isle_fn = builtin_decl_explicit (BUILT_IN_ISLESSEQUAL);
7602         tree type = TREE_TYPE (arg);
7603         tree orig_arg, max_exp, min_exp;
7604         machine_mode orig_mode = mode;
7605         REAL_VALUE_TYPE rmax, rmin;
7606         char buf[128];
7607
7608         orig_arg = arg = builtin_save_expr (arg);
7609         if (is_ibm_extended)
7610           {
7611             /* Use double to test the normal range of IBM extended
7612                precision.  Emin for IBM extended precision is
7613                different to emin for IEEE double, being 53 higher
7614                since the low double exponent is at least 53 lower
7615                than the high double exponent.  */
7616             type = double_type_node;
7617             mode = DFmode;
7618             arg = fold_build1_loc (loc, NOP_EXPR, type, arg);
7619           }
7620         arg = fold_build1_loc (loc, ABS_EXPR, type, arg);
7621
7622         get_max_float (REAL_MODE_FORMAT (mode), buf, sizeof (buf));
7623         real_from_string (&rmax, buf);
7624         sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (orig_mode)->emin - 1);
7625         real_from_string (&rmin, buf);
7626         max_exp = build_real (type, rmax);
7627         min_exp = build_real (type, rmin);
7628
7629         max_exp = build_call_expr (isle_fn, 2, arg, max_exp);
7630         if (is_ibm_extended)
7631           {
7632             /* Testing the high end of the range is done just using
7633                the high double, using the same test as isfinite().
7634                For the subnormal end of the range we first test the
7635                high double, then if its magnitude is equal to the
7636                limit of 0x1p-969, we test whether the low double is
7637                non-zero and opposite sign to the high double.  */
7638             tree const islt_fn = builtin_decl_explicit (BUILT_IN_ISLESS);
7639             tree const isgt_fn = builtin_decl_explicit (BUILT_IN_ISGREATER);
7640             tree gt_min = build_call_expr (isgt_fn, 2, arg, min_exp);
7641             tree eq_min = fold_build2 (EQ_EXPR, integer_type_node,
7642                                        arg, min_exp);
7643             tree as_complex = build1 (VIEW_CONVERT_EXPR,
7644                                       complex_double_type_node, orig_arg);
7645             tree hi_dbl = build1 (REALPART_EXPR, type, as_complex);
7646             tree lo_dbl = build1 (IMAGPART_EXPR, type, as_complex);
7647             tree zero = build_real (type, dconst0);
7648             tree hilt = build_call_expr (islt_fn, 2, hi_dbl, zero);
7649             tree lolt = build_call_expr (islt_fn, 2, lo_dbl, zero);
7650             tree logt = build_call_expr (isgt_fn, 2, lo_dbl, zero);
7651             tree ok_lo = fold_build1 (TRUTH_NOT_EXPR, integer_type_node,
7652                                       fold_build3 (COND_EXPR,
7653                                                    integer_type_node,
7654                                                    hilt, logt, lolt));
7655             eq_min = fold_build2 (TRUTH_ANDIF_EXPR, integer_type_node,
7656                                   eq_min, ok_lo);
7657             min_exp = fold_build2 (TRUTH_ORIF_EXPR, integer_type_node,
7658                                    gt_min, eq_min);
7659           }
7660         else
7661           {
7662             tree const isge_fn
7663               = builtin_decl_explicit (BUILT_IN_ISGREATEREQUAL);
7664             min_exp = build_call_expr (isge_fn, 2, arg, min_exp);
7665           }
7666         result = fold_build2 (BIT_AND_EXPR, integer_type_node,
7667                               max_exp, min_exp);
7668         return result;
7669       }
7670     default:
7671       break;
7672     }
7673
7674   return NULL_TREE;
7675 }
7676
7677 /* Fold a call to __builtin_isnan(), __builtin_isinf, __builtin_finite.
7678    ARG is the argument for the call.  */
7679
7680 static tree
7681 fold_builtin_classify (location_t loc, tree fndecl, tree arg, int builtin_index)
7682 {
7683   tree type = TREE_TYPE (TREE_TYPE (fndecl));
7684
7685   if (!validate_arg (arg, REAL_TYPE))
7686     return NULL_TREE;
7687
7688   switch (builtin_index)
7689     {
7690     case BUILT_IN_ISINF:
7691       if (!HONOR_INFINITIES (arg))
7692         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
7693
7694       return NULL_TREE;
7695
7696     case BUILT_IN_ISINF_SIGN:
7697       {
7698         /* isinf_sign(x) -> isinf(x) ? (signbit(x) ? -1 : 1) : 0 */
7699         /* In a boolean context, GCC will fold the inner COND_EXPR to
7700            1.  So e.g. "if (isinf_sign(x))" would be folded to just
7701            "if (isinf(x) ? 1 : 0)" which becomes "if (isinf(x))". */
7702         tree signbit_fn = mathfn_built_in_1
7703           (TREE_TYPE (arg), CFN_BUILT_IN_SIGNBIT, 0);
7704         tree isinf_fn = builtin_decl_explicit (BUILT_IN_ISINF);
7705         tree tmp = NULL_TREE;
7706
7707         arg = builtin_save_expr (arg);
7708
7709         if (signbit_fn && isinf_fn)
7710           {
7711             tree signbit_call = build_call_expr_loc (loc, signbit_fn, 1, arg);
7712             tree isinf_call = build_call_expr_loc (loc, isinf_fn, 1, arg);
7713
7714             signbit_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
7715                                         signbit_call, integer_zero_node);
7716             isinf_call = fold_build2_loc (loc, NE_EXPR, integer_type_node,
7717                                       isinf_call, integer_zero_node);
7718
7719             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node, signbit_call,
7720                                integer_minus_one_node, integer_one_node);
7721             tmp = fold_build3_loc (loc, COND_EXPR, integer_type_node,
7722                                isinf_call, tmp,
7723                                integer_zero_node);
7724           }
7725
7726         return tmp;
7727       }
7728
7729     case BUILT_IN_ISFINITE:
7730       if (!HONOR_NANS (arg)
7731           && !HONOR_INFINITIES (arg))
7732         return omit_one_operand_loc (loc, type, integer_one_node, arg);
7733
7734       return NULL_TREE;
7735
7736     case BUILT_IN_ISNAN:
7737       if (!HONOR_NANS (arg))
7738         return omit_one_operand_loc (loc, type, integer_zero_node, arg);
7739
7740       {
7741         bool is_ibm_extended = MODE_COMPOSITE_P (TYPE_MODE (TREE_TYPE (arg)));
7742         if (is_ibm_extended)
7743           {
7744             /* NaN and Inf are encoded in the high-order double value
7745                only.  The low-order value is not significant.  */
7746             arg = fold_build1_loc (loc, NOP_EXPR, double_type_node, arg);
7747           }
7748       }
7749       arg = builtin_save_expr (arg);
7750       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg, arg);
7751
7752     default:
7753       gcc_unreachable ();
7754     }
7755 }
7756
7757 /* Fold a call to __builtin_fpclassify(int, int, int, int, int, ...).
7758    This builtin will generate code to return the appropriate floating
7759    point classification depending on the value of the floating point
7760    number passed in.  The possible return values must be supplied as
7761    int arguments to the call in the following order: FP_NAN, FP_INFINITE,
7762    FP_NORMAL, FP_SUBNORMAL and FP_ZERO.  The ellipses is for exactly
7763    one floating point argument which is "type generic".  */
7764
7765 static tree
7766 fold_builtin_fpclassify (location_t loc, tree *args, int nargs)
7767 {
7768   tree fp_nan, fp_infinite, fp_normal, fp_subnormal, fp_zero,
7769     arg, type, res, tmp;
7770   machine_mode mode;
7771   REAL_VALUE_TYPE r;
7772   char buf[128];
7773
7774   /* Verify the required arguments in the original call.  */
7775   if (nargs != 6
7776       || !validate_arg (args[0], INTEGER_TYPE)
7777       || !validate_arg (args[1], INTEGER_TYPE)
7778       || !validate_arg (args[2], INTEGER_TYPE)
7779       || !validate_arg (args[3], INTEGER_TYPE)
7780       || !validate_arg (args[4], INTEGER_TYPE)
7781       || !validate_arg (args[5], REAL_TYPE))
7782     return NULL_TREE;
7783
7784   fp_nan = args[0];
7785   fp_infinite = args[1];
7786   fp_normal = args[2];
7787   fp_subnormal = args[3];
7788   fp_zero = args[4];
7789   arg = args[5];
7790   type = TREE_TYPE (arg);
7791   mode = TYPE_MODE (type);
7792   arg = builtin_save_expr (fold_build1_loc (loc, ABS_EXPR, type, arg));
7793
7794   /* fpclassify(x) ->
7795        isnan(x) ? FP_NAN :
7796          (fabs(x) == Inf ? FP_INFINITE :
7797            (fabs(x) >= DBL_MIN ? FP_NORMAL :
7798              (x == 0 ? FP_ZERO : FP_SUBNORMAL))).  */
7799
7800   tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
7801                      build_real (type, dconst0));
7802   res = fold_build3_loc (loc, COND_EXPR, integer_type_node,
7803                      tmp, fp_zero, fp_subnormal);
7804
7805   sprintf (buf, "0x1p%d", REAL_MODE_FORMAT (mode)->emin - 1);
7806   real_from_string (&r, buf);
7807   tmp = fold_build2_loc (loc, GE_EXPR, integer_type_node,
7808                      arg, build_real (type, r));
7809   res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, fp_normal, res);
7810
7811   if (HONOR_INFINITIES (mode))
7812     {
7813       real_inf (&r);
7814       tmp = fold_build2_loc (loc, EQ_EXPR, integer_type_node, arg,
7815                          build_real (type, r));
7816       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp,
7817                          fp_infinite, res);
7818     }
7819
7820   if (HONOR_NANS (mode))
7821     {
7822       tmp = fold_build2_loc (loc, ORDERED_EXPR, integer_type_node, arg, arg);
7823       res = fold_build3_loc (loc, COND_EXPR, integer_type_node, tmp, res, fp_nan);
7824     }
7825
7826   return res;
7827 }
7828
7829 /* Fold a call to an unordered comparison function such as
7830    __builtin_isgreater().  FNDECL is the FUNCTION_DECL for the function
7831    being called and ARG0 and ARG1 are the arguments for the call.
7832    UNORDERED_CODE and ORDERED_CODE are comparison codes that give
7833    the opposite of the desired result.  UNORDERED_CODE is used
7834    for modes that can hold NaNs and ORDERED_CODE is used for
7835    the rest.  */
7836
7837 static tree
7838 fold_builtin_unordered_cmp (location_t loc, tree fndecl, tree arg0, tree arg1,
7839                             enum tree_code unordered_code,
7840                             enum tree_code ordered_code)
7841 {
7842   tree type = TREE_TYPE (TREE_TYPE (fndecl));
7843   enum tree_code code;
7844   tree type0, type1;
7845   enum tree_code code0, code1;
7846   tree cmp_type = NULL_TREE;
7847
7848   type0 = TREE_TYPE (arg0);
7849   type1 = TREE_TYPE (arg1);
7850
7851   code0 = TREE_CODE (type0);
7852   code1 = TREE_CODE (type1);
7853
7854   if (code0 == REAL_TYPE && code1 == REAL_TYPE)
7855     /* Choose the wider of two real types.  */
7856     cmp_type = TYPE_PRECISION (type0) >= TYPE_PRECISION (type1)
7857       ? type0 : type1;
7858   else if (code0 == REAL_TYPE && code1 == INTEGER_TYPE)
7859     cmp_type = type0;
7860   else if (code0 == INTEGER_TYPE && code1 == REAL_TYPE)
7861     cmp_type = type1;
7862
7863   arg0 = fold_convert_loc (loc, cmp_type, arg0);
7864   arg1 = fold_convert_loc (loc, cmp_type, arg1);
7865
7866   if (unordered_code == UNORDERED_EXPR)
7867     {
7868       if (!HONOR_NANS (arg0))
7869         return omit_two_operands_loc (loc, type, integer_zero_node, arg0, arg1);
7870       return fold_build2_loc (loc, UNORDERED_EXPR, type, arg0, arg1);
7871     }
7872
7873   code = HONOR_NANS (arg0) ? unordered_code : ordered_code;
7874   return fold_build1_loc (loc, TRUTH_NOT_EXPR, type,
7875                       fold_build2_loc (loc, code, type, arg0, arg1));
7876 }
7877
7878 /* Fold __builtin_{,s,u}{add,sub,mul}{,l,ll}_overflow, either into normal
7879    arithmetics if it can never overflow, or into internal functions that
7880    return both result of arithmetics and overflowed boolean flag in
7881    a complex integer result, or some other check for overflow.  */
7882
7883 static tree
7884 fold_builtin_arith_overflow (location_t loc, enum built_in_function fcode,
7885                              tree arg0, tree arg1, tree arg2)
7886 {
7887   enum internal_fn ifn = IFN_LAST;
7888   tree type = TREE_TYPE (TREE_TYPE (arg2));
7889   tree mem_arg2 = build_fold_indirect_ref_loc (loc, arg2);
7890   switch (fcode)
7891     {
7892     case BUILT_IN_ADD_OVERFLOW:
7893     case BUILT_IN_SADD_OVERFLOW:
7894     case BUILT_IN_SADDL_OVERFLOW:
7895     case BUILT_IN_SADDLL_OVERFLOW:
7896     case BUILT_IN_UADD_OVERFLOW:
7897     case BUILT_IN_UADDL_OVERFLOW:
7898     case BUILT_IN_UADDLL_OVERFLOW:
7899       ifn = IFN_ADD_OVERFLOW;
7900       break;
7901     case BUILT_IN_SUB_OVERFLOW:
7902     case BUILT_IN_SSUB_OVERFLOW:
7903     case BUILT_IN_SSUBL_OVERFLOW:
7904     case BUILT_IN_SSUBLL_OVERFLOW:
7905     case BUILT_IN_USUB_OVERFLOW:
7906     case BUILT_IN_USUBL_OVERFLOW:
7907     case BUILT_IN_USUBLL_OVERFLOW:
7908       ifn = IFN_SUB_OVERFLOW;
7909       break;
7910     case BUILT_IN_MUL_OVERFLOW:
7911     case BUILT_IN_SMUL_OVERFLOW:
7912     case BUILT_IN_SMULL_OVERFLOW:
7913     case BUILT_IN_SMULLL_OVERFLOW:
7914     case BUILT_IN_UMUL_OVERFLOW:
7915     case BUILT_IN_UMULL_OVERFLOW:
7916     case BUILT_IN_UMULLL_OVERFLOW:
7917       ifn = IFN_MUL_OVERFLOW;
7918       break;
7919     default:
7920       gcc_unreachable ();
7921     }
7922   tree ctype = build_complex_type (type);
7923   tree call = build_call_expr_internal_loc (loc, ifn, ctype,
7924                                             2, arg0, arg1);
7925   tree tgt = save_expr (call);
7926   tree intres = build1_loc (loc, REALPART_EXPR, type, tgt);
7927   tree ovfres = build1_loc (loc, IMAGPART_EXPR, type, tgt);
7928   ovfres = fold_convert_loc (loc, boolean_type_node, ovfres);
7929   tree store
7930     = fold_build2_loc (loc, MODIFY_EXPR, void_type_node, mem_arg2, intres);
7931   return build2_loc (loc, COMPOUND_EXPR, boolean_type_node, store, ovfres);
7932 }
7933
7934 /* Fold a call to built-in function FNDECL with 0 arguments.
7935    This function returns NULL_TREE if no simplification was possible.  */
7936
7937 static tree
7938 fold_builtin_0 (location_t loc, tree fndecl)
7939 {
7940   tree type = TREE_TYPE (TREE_TYPE (fndecl));
7941   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7942   switch (fcode)
7943     {
7944     CASE_FLT_FN (BUILT_IN_INF):
7945     case BUILT_IN_INFD32:
7946     case BUILT_IN_INFD64:
7947     case BUILT_IN_INFD128:
7948       return fold_builtin_inf (loc, type, true);
7949
7950     CASE_FLT_FN (BUILT_IN_HUGE_VAL):
7951       return fold_builtin_inf (loc, type, false);
7952
7953     case BUILT_IN_CLASSIFY_TYPE:
7954       return fold_builtin_classify_type (NULL_TREE);
7955
7956     default:
7957       break;
7958     }
7959   return NULL_TREE;
7960 }
7961
7962 /* Fold a call to built-in function FNDECL with 1 argument, ARG0.
7963    This function returns NULL_TREE if no simplification was possible.  */
7964
7965 static tree
7966 fold_builtin_1 (location_t loc, tree fndecl, tree arg0)
7967 {
7968   tree type = TREE_TYPE (TREE_TYPE (fndecl));
7969   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
7970
7971   if (TREE_CODE (arg0) == ERROR_MARK)
7972     return NULL_TREE;
7973
7974   if (tree ret = fold_const_call (as_combined_fn (fcode), type, arg0))
7975     return ret;
7976
7977   switch (fcode)
7978     {
7979     case BUILT_IN_CONSTANT_P:
7980       {
7981         tree val = fold_builtin_constant_p (arg0);
7982
7983         /* Gimplification will pull the CALL_EXPR for the builtin out of
7984            an if condition.  When not optimizing, we'll not CSE it back.
7985            To avoid link error types of regressions, return false now.  */
7986         if (!val && !optimize)
7987           val = integer_zero_node;
7988
7989         return val;
7990       }
7991
7992     case BUILT_IN_CLASSIFY_TYPE:
7993       return fold_builtin_classify_type (arg0);
7994
7995     case BUILT_IN_STRLEN:
7996       return fold_builtin_strlen (loc, type, arg0);
7997
7998     CASE_FLT_FN (BUILT_IN_FABS):
7999     case BUILT_IN_FABSD32:
8000     case BUILT_IN_FABSD64:
8001     case BUILT_IN_FABSD128:
8002       return fold_builtin_fabs (loc, arg0, type);
8003
8004     case BUILT_IN_ABS:
8005     case BUILT_IN_LABS:
8006     case BUILT_IN_LLABS:
8007     case BUILT_IN_IMAXABS:
8008       return fold_builtin_abs (loc, arg0, type);
8009
8010     CASE_FLT_FN (BUILT_IN_CONJ):
8011       if (validate_arg (arg0, COMPLEX_TYPE)
8012         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
8013         return fold_build1_loc (loc, CONJ_EXPR, type, arg0);
8014     break;
8015
8016     CASE_FLT_FN (BUILT_IN_CREAL):
8017       if (validate_arg (arg0, COMPLEX_TYPE)
8018         && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
8019         return non_lvalue_loc (loc, fold_build1_loc (loc, REALPART_EXPR, type, arg0));
8020     break;
8021
8022     CASE_FLT_FN (BUILT_IN_CIMAG):
8023       if (validate_arg (arg0, COMPLEX_TYPE)
8024           && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE)
8025         return non_lvalue_loc (loc, fold_build1_loc (loc, IMAGPART_EXPR, type, arg0));
8026     break;
8027
8028     CASE_FLT_FN (BUILT_IN_CARG):
8029       return fold_builtin_carg (loc, arg0, type);
8030
8031     case BUILT_IN_ISASCII:
8032       return fold_builtin_isascii (loc, arg0);
8033
8034     case BUILT_IN_TOASCII:
8035       return fold_builtin_toascii (loc, arg0);
8036
8037     case BUILT_IN_ISDIGIT:
8038       return fold_builtin_isdigit (loc, arg0);
8039
8040     CASE_FLT_FN (BUILT_IN_FINITE):
8041     case BUILT_IN_FINITED32:
8042     case BUILT_IN_FINITED64:
8043     case BUILT_IN_FINITED128:
8044     case BUILT_IN_ISFINITE:
8045       {
8046         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISFINITE);
8047         if (ret)
8048           return ret;
8049         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
8050       }
8051
8052     CASE_FLT_FN (BUILT_IN_ISINF):
8053     case BUILT_IN_ISINFD32:
8054     case BUILT_IN_ISINFD64:
8055     case BUILT_IN_ISINFD128:
8056       {
8057         tree ret = fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF);
8058         if (ret)
8059           return ret;
8060         return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
8061       }
8062
8063     case BUILT_IN_ISNORMAL:
8064       return fold_builtin_interclass_mathfn (loc, fndecl, arg0);
8065
8066     case BUILT_IN_ISINF_SIGN:
8067       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISINF_SIGN);
8068
8069     CASE_FLT_FN (BUILT_IN_ISNAN):
8070     case BUILT_IN_ISNAND32:
8071     case BUILT_IN_ISNAND64:
8072     case BUILT_IN_ISNAND128:
8073       return fold_builtin_classify (loc, fndecl, arg0, BUILT_IN_ISNAN);
8074
8075     case BUILT_IN_FREE:
8076       if (integer_zerop (arg0))
8077         return build_empty_stmt (loc);
8078       break;
8079
8080     default:
8081       break;
8082     }
8083
8084   return NULL_TREE;
8085
8086 }
8087
8088 /* Fold a call to built-in function FNDECL with 2 arguments, ARG0 and ARG1.
8089    This function returns NULL_TREE if no simplification was possible.  */
8090
8091 static tree
8092 fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1)
8093 {
8094   tree type = TREE_TYPE (TREE_TYPE (fndecl));
8095   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
8096
8097   if (TREE_CODE (arg0) == ERROR_MARK
8098       || TREE_CODE (arg1) == ERROR_MARK)
8099     return NULL_TREE;
8100
8101   if (tree ret = fold_const_call (as_combined_fn (fcode), type, arg0, arg1))
8102     return ret;
8103
8104   switch (fcode)
8105     {
8106     CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
8107     CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
8108       if (validate_arg (arg0, REAL_TYPE)
8109           && validate_arg (arg1, POINTER_TYPE))
8110         return do_mpfr_lgamma_r (arg0, arg1, type);
8111     break;
8112
8113     CASE_FLT_FN (BUILT_IN_FREXP):
8114       return fold_builtin_frexp (loc, arg0, arg1, type);
8115
8116     CASE_FLT_FN (BUILT_IN_MODF):
8117       return fold_builtin_modf (loc, arg0, arg1, type);
8118
8119     case BUILT_IN_STRSTR:
8120       return fold_builtin_strstr (loc, arg0, arg1, type);
8121
8122     case BUILT_IN_STRSPN:
8123       return fold_builtin_strspn (loc, arg0, arg1);
8124
8125     case BUILT_IN_STRCSPN:
8126       return fold_builtin_strcspn (loc, arg0, arg1);
8127
8128     case BUILT_IN_STRCHR:
8129     case BUILT_IN_INDEX:
8130       return fold_builtin_strchr (loc, arg0, arg1, type);
8131
8132     case BUILT_IN_STRRCHR:
8133     case BUILT_IN_RINDEX:
8134       return fold_builtin_strrchr (loc, arg0, arg1, type);
8135
8136     case BUILT_IN_STRCMP:
8137       return fold_builtin_strcmp (loc, arg0, arg1);
8138
8139     case BUILT_IN_STRPBRK:
8140       return fold_builtin_strpbrk (loc, arg0, arg1, type);
8141
8142     case BUILT_IN_EXPECT:
8143       return fold_builtin_expect (loc, arg0, arg1, NULL_TREE);
8144
8145     case BUILT_IN_ISGREATER:
8146       return fold_builtin_unordered_cmp (loc, fndecl,
8147                                          arg0, arg1, UNLE_EXPR, LE_EXPR);
8148     case BUILT_IN_ISGREATEREQUAL:
8149       return fold_builtin_unordered_cmp (loc, fndecl,
8150                                          arg0, arg1, UNLT_EXPR, LT_EXPR);
8151     case BUILT_IN_ISLESS:
8152       return fold_builtin_unordered_cmp (loc, fndecl,
8153                                          arg0, arg1, UNGE_EXPR, GE_EXPR);
8154     case BUILT_IN_ISLESSEQUAL:
8155       return fold_builtin_unordered_cmp (loc, fndecl,
8156                                          arg0, arg1, UNGT_EXPR, GT_EXPR);
8157     case BUILT_IN_ISLESSGREATER:
8158       return fold_builtin_unordered_cmp (loc, fndecl,
8159                                          arg0, arg1, UNEQ_EXPR, EQ_EXPR);
8160     case BUILT_IN_ISUNORDERED:
8161       return fold_builtin_unordered_cmp (loc, fndecl,
8162                                          arg0, arg1, UNORDERED_EXPR,
8163                                          NOP_EXPR);
8164
8165       /* We do the folding for va_start in the expander.  */
8166     case BUILT_IN_VA_START:
8167       break;
8168
8169     case BUILT_IN_OBJECT_SIZE:
8170       return fold_builtin_object_size (arg0, arg1);
8171
8172     case BUILT_IN_ATOMIC_ALWAYS_LOCK_FREE:
8173       return fold_builtin_atomic_always_lock_free (arg0, arg1);
8174
8175     case BUILT_IN_ATOMIC_IS_LOCK_FREE:
8176       return fold_builtin_atomic_is_lock_free (arg0, arg1);
8177
8178     default:
8179       break;
8180     }
8181   return NULL_TREE;
8182 }
8183
8184 /* Fold a call to built-in function FNDECL with 3 arguments, ARG0, ARG1,
8185    and ARG2.
8186    This function returns NULL_TREE if no simplification was possible.  */
8187
8188 static tree
8189 fold_builtin_3 (location_t loc, tree fndecl,
8190                 tree arg0, tree arg1, tree arg2)
8191 {
8192   tree type = TREE_TYPE (TREE_TYPE (fndecl));
8193   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
8194
8195   if (TREE_CODE (arg0) == ERROR_MARK
8196       || TREE_CODE (arg1) == ERROR_MARK
8197       || TREE_CODE (arg2) == ERROR_MARK)
8198     return NULL_TREE;
8199
8200   if (tree ret = fold_const_call (as_combined_fn (fcode), type,
8201                                   arg0, arg1, arg2))
8202     return ret;
8203
8204   switch (fcode)
8205     {
8206
8207     CASE_FLT_FN (BUILT_IN_SINCOS):
8208       return fold_builtin_sincos (loc, arg0, arg1, arg2);
8209
8210     CASE_FLT_FN (BUILT_IN_FMA):
8211       return fold_builtin_fma (loc, arg0, arg1, arg2, type);
8212
8213     CASE_FLT_FN (BUILT_IN_REMQUO):
8214       if (validate_arg (arg0, REAL_TYPE)
8215           && validate_arg (arg1, REAL_TYPE)
8216           && validate_arg (arg2, POINTER_TYPE))
8217         return do_mpfr_remquo (arg0, arg1, arg2);
8218     break;
8219
8220     case BUILT_IN_STRNCMP:
8221       return fold_builtin_strncmp (loc, arg0, arg1, arg2);
8222
8223     case BUILT_IN_MEMCHR:
8224       return fold_builtin_memchr (loc, arg0, arg1, arg2, type);
8225
8226     case BUILT_IN_BCMP:
8227     case BUILT_IN_MEMCMP:
8228       return fold_builtin_memcmp (loc, arg0, arg1, arg2);;
8229
8230     case BUILT_IN_EXPECT:
8231       return fold_builtin_expect (loc, arg0, arg1, arg2);
8232
8233     case BUILT_IN_ADD_OVERFLOW:
8234     case BUILT_IN_SUB_OVERFLOW:
8235     case BUILT_IN_MUL_OVERFLOW:
8236     case BUILT_IN_SADD_OVERFLOW:
8237     case BUILT_IN_SADDL_OVERFLOW:
8238     case BUILT_IN_SADDLL_OVERFLOW:
8239     case BUILT_IN_SSUB_OVERFLOW:
8240     case BUILT_IN_SSUBL_OVERFLOW:
8241     case BUILT_IN_SSUBLL_OVERFLOW:
8242     case BUILT_IN_SMUL_OVERFLOW:
8243     case BUILT_IN_SMULL_OVERFLOW:
8244     case BUILT_IN_SMULLL_OVERFLOW:
8245     case BUILT_IN_UADD_OVERFLOW:
8246     case BUILT_IN_UADDL_OVERFLOW:
8247     case BUILT_IN_UADDLL_OVERFLOW:
8248     case BUILT_IN_USUB_OVERFLOW:
8249     case BUILT_IN_USUBL_OVERFLOW:
8250     case BUILT_IN_USUBLL_OVERFLOW:
8251     case BUILT_IN_UMUL_OVERFLOW:
8252     case BUILT_IN_UMULL_OVERFLOW:
8253     case BUILT_IN_UMULLL_OVERFLOW:
8254       return fold_builtin_arith_overflow (loc, fcode, arg0, arg1, arg2);
8255
8256     default:
8257       break;
8258     }
8259   return NULL_TREE;
8260 }
8261
8262 /* Fold a call to built-in function FNDECL.  ARGS is an array of NARGS
8263    arguments.  IGNORE is true if the result of the
8264    function call is ignored.  This function returns NULL_TREE if no
8265    simplification was possible.  */
8266
8267 tree
8268 fold_builtin_n (location_t loc, tree fndecl, tree *args, int nargs, bool)
8269 {
8270   tree ret = NULL_TREE;
8271
8272   switch (nargs)
8273     {
8274     case 0:
8275       ret = fold_builtin_0 (loc, fndecl);
8276       break;
8277     case 1:
8278       ret = fold_builtin_1 (loc, fndecl, args[0]);
8279       break;
8280     case 2:
8281       ret = fold_builtin_2 (loc, fndecl, args[0], args[1]);
8282       break;
8283     case 3:
8284       ret = fold_builtin_3 (loc, fndecl, args[0], args[1], args[2]);
8285       break;
8286     default:
8287       ret = fold_builtin_varargs (loc, fndecl, args, nargs);
8288       break;
8289     }
8290   if (ret)
8291     {
8292       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
8293       SET_EXPR_LOCATION (ret, loc);
8294       TREE_NO_WARNING (ret) = 1;
8295       return ret;
8296     }
8297   return NULL_TREE;
8298 }
8299
8300 /* Construct a new CALL_EXPR to FNDECL using the tail of the argument
8301    list ARGS along with N new arguments in NEWARGS.  SKIP is the number
8302    of arguments in ARGS to be omitted.  OLDNARGS is the number of
8303    elements in ARGS.  */
8304
8305 static tree
8306 rewrite_call_expr_valist (location_t loc, int oldnargs, tree *args,
8307                           int skip, tree fndecl, int n, va_list newargs)
8308 {
8309   int nargs = oldnargs - skip + n;
8310   tree *buffer;
8311
8312   if (n > 0)
8313     {
8314       int i, j;
8315
8316       buffer = XALLOCAVEC (tree, nargs);
8317       for (i = 0; i < n; i++)
8318         buffer[i] = va_arg (newargs, tree);
8319       for (j = skip; j < oldnargs; j++, i++)
8320         buffer[i] = args[j];
8321     }
8322   else
8323     buffer = args + skip;
8324
8325   return build_call_expr_loc_array (loc, fndecl, nargs, buffer);
8326 }
8327
8328 /* Return true if FNDECL shouldn't be folded right now.
8329    If a built-in function has an inline attribute always_inline
8330    wrapper, defer folding it after always_inline functions have
8331    been inlined, otherwise e.g. -D_FORTIFY_SOURCE checking
8332    might not be performed.  */
8333
8334 bool
8335 avoid_folding_inline_builtin (tree fndecl)
8336 {
8337   return (DECL_DECLARED_INLINE_P (fndecl)
8338           && DECL_DISREGARD_INLINE_LIMITS (fndecl)
8339           && cfun
8340           && !cfun->always_inline_functions_inlined
8341           && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fndecl)));
8342 }
8343
8344 /* A wrapper function for builtin folding that prevents warnings for
8345    "statement without effect" and the like, caused by removing the
8346    call node earlier than the warning is generated.  */
8347
8348 tree
8349 fold_call_expr (location_t loc, tree exp, bool ignore)
8350 {
8351   tree ret = NULL_TREE;
8352   tree fndecl = get_callee_fndecl (exp);
8353   if (fndecl
8354       && TREE_CODE (fndecl) == FUNCTION_DECL
8355       && DECL_BUILT_IN (fndecl)
8356       /* If CALL_EXPR_VA_ARG_PACK is set, the arguments aren't finalized
8357          yet.  Defer folding until we see all the arguments
8358          (after inlining).  */
8359       && !CALL_EXPR_VA_ARG_PACK (exp))
8360     {
8361       int nargs = call_expr_nargs (exp);
8362
8363       /* Before gimplification CALL_EXPR_VA_ARG_PACK is not set, but
8364          instead last argument is __builtin_va_arg_pack ().  Defer folding
8365          even in that case, until arguments are finalized.  */
8366       if (nargs && TREE_CODE (CALL_EXPR_ARG (exp, nargs - 1)) == CALL_EXPR)
8367         {
8368           tree fndecl2 = get_callee_fndecl (CALL_EXPR_ARG (exp, nargs - 1));
8369           if (fndecl2
8370               && TREE_CODE (fndecl2) == FUNCTION_DECL
8371               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
8372               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
8373             return NULL_TREE;
8374         }
8375
8376       if (avoid_folding_inline_builtin (fndecl))
8377         return NULL_TREE;
8378
8379       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
8380         return targetm.fold_builtin (fndecl, call_expr_nargs (exp),
8381                                      CALL_EXPR_ARGP (exp), ignore);
8382       else
8383         {
8384           tree *args = CALL_EXPR_ARGP (exp);
8385           ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
8386           if (ret)
8387             return ret;
8388         }
8389     }
8390   return NULL_TREE;
8391 }
8392
8393 /* Fold a CALL_EXPR with type TYPE with FN as the function expression.
8394    N arguments are passed in the array ARGARRAY.  Return a folded
8395    expression or NULL_TREE if no simplification was possible.  */
8396
8397 tree
8398 fold_builtin_call_array (location_t loc, tree,
8399                          tree fn,
8400                          int n,
8401                          tree *argarray)
8402 {
8403   if (TREE_CODE (fn) != ADDR_EXPR)
8404     return NULL_TREE;
8405
8406   tree fndecl = TREE_OPERAND (fn, 0);
8407   if (TREE_CODE (fndecl) == FUNCTION_DECL
8408       && DECL_BUILT_IN (fndecl))
8409     {
8410       /* If last argument is __builtin_va_arg_pack (), arguments to this
8411          function are not finalized yet.  Defer folding until they are.  */
8412       if (n && TREE_CODE (argarray[n - 1]) == CALL_EXPR)
8413         {
8414           tree fndecl2 = get_callee_fndecl (argarray[n - 1]);
8415           if (fndecl2
8416               && TREE_CODE (fndecl2) == FUNCTION_DECL
8417               && DECL_BUILT_IN_CLASS (fndecl2) == BUILT_IN_NORMAL
8418               && DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_VA_ARG_PACK)
8419             return NULL_TREE;
8420         }
8421       if (avoid_folding_inline_builtin (fndecl))
8422         return NULL_TREE;
8423       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
8424         return targetm.fold_builtin (fndecl, n, argarray, false);
8425       else
8426         return fold_builtin_n (loc, fndecl, argarray, n, false);
8427     }
8428
8429   return NULL_TREE;
8430 }
8431
8432 /* Construct a new CALL_EXPR using the tail of the argument list of EXP
8433    along with N new arguments specified as the "..." parameters.  SKIP
8434    is the number of arguments in EXP to be omitted.  This function is used
8435    to do varargs-to-varargs transformations.  */
8436
8437 static tree
8438 rewrite_call_expr (location_t loc, tree exp, int skip, tree fndecl, int n, ...)
8439 {
8440   va_list ap;
8441   tree t;
8442
8443   va_start (ap, n);
8444   t = rewrite_call_expr_valist (loc, call_expr_nargs (exp),
8445                                 CALL_EXPR_ARGP (exp), skip, fndecl, n, ap);
8446   va_end (ap);
8447
8448   return t;
8449 }
8450
8451 /* Validate a single argument ARG against a tree code CODE representing
8452    a type.  */
8453
8454 static bool
8455 validate_arg (const_tree arg, enum tree_code code)
8456 {
8457   if (!arg)
8458     return false;
8459   else if (code == POINTER_TYPE)
8460     return POINTER_TYPE_P (TREE_TYPE (arg));
8461   else if (code == INTEGER_TYPE)
8462     return INTEGRAL_TYPE_P (TREE_TYPE (arg));
8463   return code == TREE_CODE (TREE_TYPE (arg));
8464 }
8465
8466 /* This function validates the types of a function call argument list
8467    against a specified list of tree_codes.  If the last specifier is a 0,
8468    that represents an ellipses, otherwise the last specifier must be a
8469    VOID_TYPE.
8470
8471    This is the GIMPLE version of validate_arglist.  Eventually we want to
8472    completely convert builtins.c to work from GIMPLEs and the tree based
8473    validate_arglist will then be removed.  */
8474
8475 bool
8476 validate_gimple_arglist (const gcall *call, ...)
8477 {
8478   enum tree_code code;
8479   bool res = 0;
8480   va_list ap;
8481   const_tree arg;
8482   size_t i;
8483
8484   va_start (ap, call);
8485   i = 0;
8486
8487   do
8488     {
8489       code = (enum tree_code) va_arg (ap, int);
8490       switch (code)
8491         {
8492         case 0:
8493           /* This signifies an ellipses, any further arguments are all ok.  */
8494           res = true;
8495           goto end;
8496         case VOID_TYPE:
8497           /* This signifies an endlink, if no arguments remain, return
8498              true, otherwise return false.  */
8499           res = (i == gimple_call_num_args (call));
8500           goto end;
8501         default:
8502           /* If no parameters remain or the parameter's code does not
8503              match the specified code, return false.  Otherwise continue
8504              checking any remaining arguments.  */
8505           arg = gimple_call_arg (call, i++);
8506           if (!validate_arg (arg, code))
8507             goto end;
8508           break;
8509         }
8510     }
8511   while (1);
8512
8513   /* We need gotos here since we can only have one VA_CLOSE in a
8514      function.  */
8515  end: ;
8516   va_end (ap);
8517
8518   return res;
8519 }
8520
8521 /* Default target-specific builtin expander that does nothing.  */
8522
8523 rtx
8524 default_expand_builtin (tree exp ATTRIBUTE_UNUSED,
8525                         rtx target ATTRIBUTE_UNUSED,
8526                         rtx subtarget ATTRIBUTE_UNUSED,
8527                         machine_mode mode ATTRIBUTE_UNUSED,
8528                         int ignore ATTRIBUTE_UNUSED)
8529 {
8530   return NULL_RTX;
8531 }
8532
8533 /* Returns true is EXP represents data that would potentially reside
8534    in a readonly section.  */
8535
8536 bool
8537 readonly_data_expr (tree exp)
8538 {
8539   STRIP_NOPS (exp);
8540
8541   if (TREE_CODE (exp) != ADDR_EXPR)
8542     return false;
8543
8544   exp = get_base_address (TREE_OPERAND (exp, 0));
8545   if (!exp)
8546     return false;
8547
8548   /* Make sure we call decl_readonly_section only for trees it
8549      can handle (since it returns true for everything it doesn't
8550      understand).  */
8551   if (TREE_CODE (exp) == STRING_CST
8552       || TREE_CODE (exp) == CONSTRUCTOR
8553       || (TREE_CODE (exp) == VAR_DECL && TREE_STATIC (exp)))
8554     return decl_readonly_section (exp, 0);
8555   else
8556     return false;
8557 }
8558
8559 /* Simplify a call to the strstr builtin.  S1 and S2 are the arguments
8560    to the call, and TYPE is its return type.
8561
8562    Return NULL_TREE if no simplification was possible, otherwise return the
8563    simplified form of the call as a tree.
8564
8565    The simplified form may be a constant or other expression which
8566    computes the same value, but in a more efficient manner (including
8567    calls to other builtin functions).
8568
8569    The call may contain arguments which need to be evaluated, but
8570    which are not useful to determine the result of the call.  In
8571    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8572    COMPOUND_EXPR will be an argument which must be evaluated.
8573    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8574    COMPOUND_EXPR in the chain will contain the tree for the simplified
8575    form of the builtin function call.  */
8576
8577 static tree
8578 fold_builtin_strstr (location_t loc, tree s1, tree s2, tree type)
8579 {
8580   if (!validate_arg (s1, POINTER_TYPE)
8581       || !validate_arg (s2, POINTER_TYPE))
8582     return NULL_TREE;
8583   else
8584     {
8585       tree fn;
8586       const char *p1, *p2;
8587
8588       p2 = c_getstr (s2);
8589       if (p2 == NULL)
8590         return NULL_TREE;
8591
8592       p1 = c_getstr (s1);
8593       if (p1 != NULL)
8594         {
8595           const char *r = strstr (p1, p2);
8596           tree tem;
8597
8598           if (r == NULL)
8599             return build_int_cst (TREE_TYPE (s1), 0);
8600
8601           /* Return an offset into the constant string argument.  */
8602           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8603           return fold_convert_loc (loc, type, tem);
8604         }
8605
8606       /* The argument is const char *, and the result is char *, so we need
8607          a type conversion here to avoid a warning.  */
8608       if (p2[0] == '\0')
8609         return fold_convert_loc (loc, type, s1);
8610
8611       if (p2[1] != '\0')
8612         return NULL_TREE;
8613
8614       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
8615       if (!fn)
8616         return NULL_TREE;
8617
8618       /* New argument list transforming strstr(s1, s2) to
8619          strchr(s1, s2[0]).  */
8620       return build_call_expr_loc (loc, fn, 2, s1,
8621                                   build_int_cst (integer_type_node, p2[0]));
8622     }
8623 }
8624
8625 /* Simplify a call to the strchr builtin.  S1 and S2 are the arguments to
8626    the call, and TYPE is its return type.
8627
8628    Return NULL_TREE if no simplification was possible, otherwise return the
8629    simplified form of the call as a tree.
8630
8631    The simplified form may be a constant or other expression which
8632    computes the same value, but in a more efficient manner (including
8633    calls to other builtin functions).
8634
8635    The call may contain arguments which need to be evaluated, but
8636    which are not useful to determine the result of the call.  In
8637    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8638    COMPOUND_EXPR will be an argument which must be evaluated.
8639    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8640    COMPOUND_EXPR in the chain will contain the tree for the simplified
8641    form of the builtin function call.  */
8642
8643 static tree
8644 fold_builtin_strchr (location_t loc, tree s1, tree s2, tree type)
8645 {
8646   if (!validate_arg (s1, POINTER_TYPE)
8647       || !validate_arg (s2, INTEGER_TYPE))
8648     return NULL_TREE;
8649   else
8650     {
8651       const char *p1;
8652
8653       if (TREE_CODE (s2) != INTEGER_CST)
8654         return NULL_TREE;
8655
8656       p1 = c_getstr (s1);
8657       if (p1 != NULL)
8658         {
8659           char c;
8660           const char *r;
8661           tree tem;
8662
8663           if (target_char_cast (s2, &c))
8664             return NULL_TREE;
8665
8666           r = strchr (p1, c);
8667
8668           if (r == NULL)
8669             return build_int_cst (TREE_TYPE (s1), 0);
8670
8671           /* Return an offset into the constant string argument.  */
8672           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8673           return fold_convert_loc (loc, type, tem);
8674         }
8675       return NULL_TREE;
8676     }
8677 }
8678
8679 /* Simplify a call to the strrchr builtin.  S1 and S2 are the arguments to
8680    the call, and TYPE is its return type.
8681
8682    Return NULL_TREE if no simplification was possible, otherwise return the
8683    simplified form of the call as a tree.
8684
8685    The simplified form may be a constant or other expression which
8686    computes the same value, but in a more efficient manner (including
8687    calls to other builtin functions).
8688
8689    The call may contain arguments which need to be evaluated, but
8690    which are not useful to determine the result of the call.  In
8691    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8692    COMPOUND_EXPR will be an argument which must be evaluated.
8693    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8694    COMPOUND_EXPR in the chain will contain the tree for the simplified
8695    form of the builtin function call.  */
8696
8697 static tree
8698 fold_builtin_strrchr (location_t loc, tree s1, tree s2, tree type)
8699 {
8700   if (!validate_arg (s1, POINTER_TYPE)
8701       || !validate_arg (s2, INTEGER_TYPE))
8702     return NULL_TREE;
8703   else
8704     {
8705       tree fn;
8706       const char *p1;
8707
8708       if (TREE_CODE (s2) != INTEGER_CST)
8709         return NULL_TREE;
8710
8711       p1 = c_getstr (s1);
8712       if (p1 != NULL)
8713         {
8714           char c;
8715           const char *r;
8716           tree tem;
8717
8718           if (target_char_cast (s2, &c))
8719             return NULL_TREE;
8720
8721           r = strrchr (p1, c);
8722
8723           if (r == NULL)
8724             return build_int_cst (TREE_TYPE (s1), 0);
8725
8726           /* Return an offset into the constant string argument.  */
8727           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8728           return fold_convert_loc (loc, type, tem);
8729         }
8730
8731       if (! integer_zerop (s2))
8732         return NULL_TREE;
8733
8734       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
8735       if (!fn)
8736         return NULL_TREE;
8737
8738       /* Transform strrchr(s1, '\0') to strchr(s1, '\0').  */
8739       return build_call_expr_loc (loc, fn, 2, s1, s2);
8740     }
8741 }
8742
8743 /* Simplify a call to the strpbrk builtin.  S1 and S2 are the arguments
8744    to the call, and TYPE is its return type.
8745
8746    Return NULL_TREE if no simplification was possible, otherwise return the
8747    simplified form of the call as a tree.
8748
8749    The simplified form may be a constant or other expression which
8750    computes the same value, but in a more efficient manner (including
8751    calls to other builtin functions).
8752
8753    The call may contain arguments which need to be evaluated, but
8754    which are not useful to determine the result of the call.  In
8755    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8756    COMPOUND_EXPR will be an argument which must be evaluated.
8757    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8758    COMPOUND_EXPR in the chain will contain the tree for the simplified
8759    form of the builtin function call.  */
8760
8761 static tree
8762 fold_builtin_strpbrk (location_t loc, tree s1, tree s2, tree type)
8763 {
8764   if (!validate_arg (s1, POINTER_TYPE)
8765       || !validate_arg (s2, POINTER_TYPE))
8766     return NULL_TREE;
8767   else
8768     {
8769       tree fn;
8770       const char *p1, *p2;
8771
8772       p2 = c_getstr (s2);
8773       if (p2 == NULL)
8774         return NULL_TREE;
8775
8776       p1 = c_getstr (s1);
8777       if (p1 != NULL)
8778         {
8779           const char *r = strpbrk (p1, p2);
8780           tree tem;
8781
8782           if (r == NULL)
8783             return build_int_cst (TREE_TYPE (s1), 0);
8784
8785           /* Return an offset into the constant string argument.  */
8786           tem = fold_build_pointer_plus_hwi_loc (loc, s1, r - p1);
8787           return fold_convert_loc (loc, type, tem);
8788         }
8789
8790       if (p2[0] == '\0')
8791         /* strpbrk(x, "") == NULL.
8792            Evaluate and ignore s1 in case it had side-effects.  */
8793         return omit_one_operand_loc (loc, TREE_TYPE (s1), integer_zero_node, s1);
8794
8795       if (p2[1] != '\0')
8796         return NULL_TREE;  /* Really call strpbrk.  */
8797
8798       fn = builtin_decl_implicit (BUILT_IN_STRCHR);
8799       if (!fn)
8800         return NULL_TREE;
8801
8802       /* New argument list transforming strpbrk(s1, s2) to
8803          strchr(s1, s2[0]).  */
8804       return build_call_expr_loc (loc, fn, 2, s1,
8805                                   build_int_cst (integer_type_node, p2[0]));
8806     }
8807 }
8808
8809 /* Simplify a call to the strspn builtin.  S1 and S2 are the arguments
8810    to the call.
8811
8812    Return NULL_TREE if no simplification was possible, otherwise return the
8813    simplified form of the call as a tree.
8814
8815    The simplified form may be a constant or other expression which
8816    computes the same value, but in a more efficient manner (including
8817    calls to other builtin functions).
8818
8819    The call may contain arguments which need to be evaluated, but
8820    which are not useful to determine the result of the call.  In
8821    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8822    COMPOUND_EXPR will be an argument which must be evaluated.
8823    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8824    COMPOUND_EXPR in the chain will contain the tree for the simplified
8825    form of the builtin function call.  */
8826
8827 static tree
8828 fold_builtin_strspn (location_t loc, tree s1, tree s2)
8829 {
8830   if (!validate_arg (s1, POINTER_TYPE)
8831       || !validate_arg (s2, POINTER_TYPE))
8832     return NULL_TREE;
8833   else
8834     {
8835       const char *p1 = c_getstr (s1), *p2 = c_getstr (s2);
8836
8837       /* If either argument is "", return NULL_TREE.  */
8838       if ((p1 && *p1 == '\0') || (p2 && *p2 == '\0'))
8839         /* Evaluate and ignore both arguments in case either one has
8840            side-effects.  */
8841         return omit_two_operands_loc (loc, size_type_node, size_zero_node,
8842                                   s1, s2);
8843       return NULL_TREE;
8844     }
8845 }
8846
8847 /* Simplify a call to the strcspn builtin.  S1 and S2 are the arguments
8848    to the call.
8849
8850    Return NULL_TREE if no simplification was possible, otherwise return the
8851    simplified form of the call as a tree.
8852
8853    The simplified form may be a constant or other expression which
8854    computes the same value, but in a more efficient manner (including
8855    calls to other builtin functions).
8856
8857    The call may contain arguments which need to be evaluated, but
8858    which are not useful to determine the result of the call.  In
8859    this case we return a chain of COMPOUND_EXPRs.  The LHS of each
8860    COMPOUND_EXPR will be an argument which must be evaluated.
8861    COMPOUND_EXPRs are chained through their RHS.  The RHS of the last
8862    COMPOUND_EXPR in the chain will contain the tree for the simplified
8863    form of the builtin function call.  */
8864
8865 static tree
8866 fold_builtin_strcspn (location_t loc, tree s1, tree s2)
8867 {
8868   if (!validate_arg (s1, POINTER_TYPE)
8869       || !validate_arg (s2, POINTER_TYPE))
8870     return NULL_TREE;
8871   else
8872     {
8873       /* If the first argument is "", return NULL_TREE.  */
8874       const char *p1 = c_getstr (s1);
8875       if (p1 && *p1 == '\0')
8876         {
8877           /* Evaluate and ignore argument s2 in case it has
8878              side-effects.  */
8879           return omit_one_operand_loc (loc, size_type_node,
8880                                    size_zero_node, s2);
8881         }
8882
8883       /* If the second argument is "", return __builtin_strlen(s1).  */
8884       const char *p2 = c_getstr (s2);
8885       if (p2 && *p2 == '\0')
8886         {
8887           tree fn = builtin_decl_implicit (BUILT_IN_STRLEN);
8888
8889           /* If the replacement _DECL isn't initialized, don't do the
8890              transformation.  */
8891           if (!fn)
8892             return NULL_TREE;
8893
8894           return build_call_expr_loc (loc, fn, 1, s1);
8895         }
8896       return NULL_TREE;
8897     }
8898 }
8899
8900 /* Fold the next_arg or va_start call EXP. Returns true if there was an error
8901    produced.  False otherwise.  This is done so that we don't output the error
8902    or warning twice or three times.  */
8903
8904 bool
8905 fold_builtin_next_arg (tree exp, bool va_start_p)
8906 {
8907   tree fntype = TREE_TYPE (current_function_decl);
8908   int nargs = call_expr_nargs (exp);
8909   tree arg;
8910   /* There is good chance the current input_location points inside the
8911      definition of the va_start macro (perhaps on the token for
8912      builtin) in a system header, so warnings will not be emitted.
8913      Use the location in real source code.  */
8914   source_location current_location =
8915     linemap_unwind_to_first_non_reserved_loc (line_table, input_location,
8916                                               NULL);
8917
8918   if (!stdarg_p (fntype))
8919     {
8920       error ("%<va_start%> used in function with fixed args");
8921       return true;
8922     }
8923
8924   if (va_start_p)
8925     {
8926       if (va_start_p && (nargs != 2))
8927         {
8928           error ("wrong number of arguments to function %<va_start%>");
8929           return true;
8930         }
8931       arg = CALL_EXPR_ARG (exp, 1);
8932     }
8933   /* We use __builtin_va_start (ap, 0, 0) or __builtin_next_arg (0, 0)
8934      when we checked the arguments and if needed issued a warning.  */
8935   else
8936     {
8937       if (nargs == 0)
8938         {
8939           /* Evidently an out of date version of <stdarg.h>; can't validate
8940              va_start's second argument, but can still work as intended.  */
8941           warning_at (current_location,
8942                       OPT_Wvarargs,
8943                    "%<__builtin_next_arg%> called without an argument");
8944           return true;
8945         }
8946       else if (nargs > 1)
8947         {
8948           error ("wrong number of arguments to function %<__builtin_next_arg%>");
8949           return true;
8950         }
8951       arg = CALL_EXPR_ARG (exp, 0);
8952     }
8953
8954   if (TREE_CODE (arg) == SSA_NAME)
8955     arg = SSA_NAME_VAR (arg);
8956
8957   /* We destructively modify the call to be __builtin_va_start (ap, 0)
8958      or __builtin_next_arg (0) the first time we see it, after checking
8959      the arguments and if needed issuing a warning.  */
8960   if (!integer_zerop (arg))
8961     {
8962       tree last_parm = tree_last (DECL_ARGUMENTS (current_function_decl));
8963
8964       /* Strip off all nops for the sake of the comparison.  This
8965          is not quite the same as STRIP_NOPS.  It does more.
8966          We must also strip off INDIRECT_EXPR for C++ reference
8967          parameters.  */
8968       while (CONVERT_EXPR_P (arg)
8969              || TREE_CODE (arg) == INDIRECT_REF)
8970         arg = TREE_OPERAND (arg, 0);
8971       if (arg != last_parm)
8972         {
8973           /* FIXME: Sometimes with the tree optimizers we can get the
8974              not the last argument even though the user used the last
8975              argument.  We just warn and set the arg to be the last
8976              argument so that we will get wrong-code because of
8977              it.  */
8978           warning_at (current_location,
8979                       OPT_Wvarargs,
8980                       "second parameter of %<va_start%> not last named argument");
8981         }
8982
8983       /* Undefined by C99 7.15.1.4p4 (va_start):
8984          "If the parameter parmN is declared with the register storage
8985          class, with a function or array type, or with a type that is
8986          not compatible with the type that results after application of
8987          the default argument promotions, the behavior is undefined."
8988       */
8989       else if (DECL_REGISTER (arg))
8990         {
8991           warning_at (current_location,
8992                       OPT_Wvarargs,
8993                       "undefined behavior when second parameter of "
8994                       "%<va_start%> is declared with %<register%> storage");
8995         }
8996
8997       /* We want to verify the second parameter just once before the tree
8998          optimizers are run and then avoid keeping it in the tree,
8999          as otherwise we could warn even for correct code like:
9000          void foo (int i, ...)
9001          { va_list ap; i++; va_start (ap, i); va_end (ap); }  */
9002       if (va_start_p)
9003         CALL_EXPR_ARG (exp, 1) = integer_zero_node;
9004       else
9005         CALL_EXPR_ARG (exp, 0) = integer_zero_node;
9006     }
9007   return false;
9008 }
9009
9010
9011 /* Expand a call EXP to __builtin_object_size.  */
9012
9013 static rtx
9014 expand_builtin_object_size (tree exp)
9015 {
9016   tree ost;
9017   int object_size_type;
9018   tree fndecl = get_callee_fndecl (exp);
9019
9020   if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE))
9021     {
9022       error ("%Kfirst argument of %D must be a pointer, second integer constant",
9023              exp, fndecl);
9024       expand_builtin_trap ();
9025       return const0_rtx;
9026     }
9027
9028   ost = CALL_EXPR_ARG (exp, 1);
9029   STRIP_NOPS (ost);
9030
9031   if (TREE_CODE (ost) != INTEGER_CST
9032       || tree_int_cst_sgn (ost) < 0
9033       || compare_tree_int (ost, 3) > 0)
9034     {
9035       error ("%Klast argument of %D is not integer constant between 0 and 3",
9036              exp, fndecl);
9037       expand_builtin_trap ();
9038       return const0_rtx;
9039     }
9040
9041   object_size_type = tree_to_shwi (ost);
9042
9043   return object_size_type < 2 ? constm1_rtx : const0_rtx;
9044 }
9045
9046 /* Expand EXP, a call to the __mem{cpy,pcpy,move,set}_chk builtin.
9047    FCODE is the BUILT_IN_* to use.
9048    Return NULL_RTX if we failed; the caller should emit a normal call,
9049    otherwise try to get the result in TARGET, if convenient (and in
9050    mode MODE if that's convenient).  */
9051
9052 static rtx
9053 expand_builtin_memory_chk (tree exp, rtx target, machine_mode mode,
9054                            enum built_in_function fcode)
9055 {
9056   tree dest, src, len, size;
9057
9058   if (!validate_arglist (exp,
9059                          POINTER_TYPE,
9060                          fcode == BUILT_IN_MEMSET_CHK
9061                          ? INTEGER_TYPE : POINTER_TYPE,
9062                          INTEGER_TYPE, INTEGER_TYPE, VOID_TYPE))
9063     return NULL_RTX;
9064
9065   dest = CALL_EXPR_ARG (exp, 0);
9066   src = CALL_EXPR_ARG (exp, 1);
9067   len = CALL_EXPR_ARG (exp, 2);
9068   size = CALL_EXPR_ARG (exp, 3);
9069
9070   if (! tree_fits_uhwi_p (size))
9071     return NULL_RTX;
9072
9073   if (tree_fits_uhwi_p (len) || integer_all_onesp (size))
9074     {
9075       tree fn;
9076
9077       if (! integer_all_onesp (size) && tree_int_cst_lt (size, len))
9078         {
9079           warning_at (tree_nonartificial_location (exp),
9080                       0, "%Kcall to %D will always overflow destination buffer",
9081                       exp, get_callee_fndecl (exp));
9082           return NULL_RTX;
9083         }
9084
9085       fn = NULL_TREE;
9086       /* If __builtin_mem{cpy,pcpy,move,set}_chk is used, assume
9087          mem{cpy,pcpy,move,set} is available.  */
9088       switch (fcode)
9089         {
9090         case BUILT_IN_MEMCPY_CHK:
9091           fn = builtin_decl_explicit (BUILT_IN_MEMCPY);
9092           break;
9093         case BUILT_IN_MEMPCPY_CHK:
9094           fn = builtin_decl_explicit (BUILT_IN_MEMPCPY);
9095           break;
9096         case BUILT_IN_MEMMOVE_CHK:
9097           fn = builtin_decl_explicit (BUILT_IN_MEMMOVE);
9098           break;
9099         case BUILT_IN_MEMSET_CHK:
9100           fn = builtin_decl_explicit (BUILT_IN_MEMSET);
9101           break;
9102         default:
9103           break;
9104         }
9105
9106       if (! fn)
9107         return NULL_RTX;
9108
9109       fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 3, dest, src, len);
9110       gcc_assert (TREE_CODE (fn) == CALL_EXPR);
9111       CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
9112       return expand_expr (fn, target, mode, EXPAND_NORMAL);
9113     }
9114   else if (fcode == BUILT_IN_MEMSET_CHK)
9115     return NULL_RTX;
9116   else
9117     {
9118       unsigned int dest_align = get_pointer_alignment (dest);
9119
9120       /* If DEST is not a pointer type, call the normal function.  */
9121       if (dest_align == 0)
9122         return NULL_RTX;
9123
9124       /* If SRC and DEST are the same (and not volatile), do nothing.  */
9125       if (operand_equal_p (src, dest, 0))
9126         {
9127           tree expr;
9128
9129           if (fcode != BUILT_IN_MEMPCPY_CHK)
9130             {
9131               /* Evaluate and ignore LEN in case it has side-effects.  */
9132               expand_expr (len, const0_rtx, VOIDmode, EXPAND_NORMAL);
9133               return expand_expr (dest, target, mode, EXPAND_NORMAL);
9134             }
9135
9136           expr = fold_build_pointer_plus (dest, len);
9137           return expand_expr (expr, target, mode, EXPAND_NORMAL);
9138         }
9139
9140       /* __memmove_chk special case.  */
9141       if (fcode == BUILT_IN_MEMMOVE_CHK)
9142         {
9143           unsigned int src_align = get_pointer_alignment (src);
9144
9145           if (src_align == 0)
9146             return NULL_RTX;
9147
9148           /* If src is categorized for a readonly section we can use
9149              normal __memcpy_chk.  */
9150           if (readonly_data_expr (src))
9151             {
9152               tree fn = builtin_decl_explicit (BUILT_IN_MEMCPY_CHK);
9153               if (!fn)
9154                 return NULL_RTX;
9155               fn = build_call_nofold_loc (EXPR_LOCATION (exp), fn, 4,
9156                                           dest, src, len, size);
9157               gcc_assert (TREE_CODE (fn) == CALL_EXPR);
9158               CALL_EXPR_TAILCALL (fn) = CALL_EXPR_TAILCALL (exp);
9159               return expand_expr (fn, target, mode, EXPAND_NORMAL);
9160             }
9161         }
9162       return NULL_RTX;
9163     }
9164 }
9165
9166 /* Emit warning if a buffer overflow is detected at compile time.  */
9167
9168 static void
9169 maybe_emit_chk_warning (tree exp, enum built_in_function fcode)
9170 {
9171   int is_strlen = 0;
9172   tree len, size;
9173   location_t loc = tree_nonartificial_location (exp);
9174
9175   switch (fcode)
9176     {
9177     case BUILT_IN_STRCPY_CHK:
9178     case BUILT_IN_STPCPY_CHK:
9179     /* For __strcat_chk the warning will be emitted only if overflowing
9180        by at least strlen (dest) + 1 bytes.  */
9181     case BUILT_IN_STRCAT_CHK:
9182       len = CALL_EXPR_ARG (exp, 1);
9183       size = CALL_EXPR_ARG (exp, 2);
9184       is_strlen = 1;
9185       break;
9186     case BUILT_IN_STRNCAT_CHK:
9187     case BUILT_IN_STRNCPY_CHK:
9188     case BUILT_IN_STPNCPY_CHK:
9189       len = CALL_EXPR_ARG (exp, 2);
9190       size = CALL_EXPR_ARG (exp, 3);
9191       break;
9192     case BUILT_IN_SNPRINTF_CHK:
9193     case BUILT_IN_VSNPRINTF_CHK:
9194       len = CALL_EXPR_ARG (exp, 1);
9195       size = CALL_EXPR_ARG (exp, 3);
9196       break;
9197     default:
9198       gcc_unreachable ();
9199     }
9200
9201   if (!len || !size)
9202     return;
9203
9204   if (! tree_fits_uhwi_p (size) || integer_all_onesp (size))
9205     return;
9206
9207   if (is_strlen)
9208     {
9209       len = c_strlen (len, 1);
9210       if (! len || ! tree_fits_uhwi_p (len) || tree_int_cst_lt (len, size))
9211         return;
9212     }
9213   else if (fcode == BUILT_IN_STRNCAT_CHK)
9214     {
9215       tree src = CALL_EXPR_ARG (exp, 1);
9216       if (! src || ! tree_fits_uhwi_p (len) || tree_int_cst_lt (len, size))
9217         return;
9218       src = c_strlen (src, 1);
9219       if (! src || ! tree_fits_uhwi_p (src))
9220         {
9221           warning_at (loc, 0, "%Kcall to %D might overflow destination buffer",
9222                       exp, get_callee_fndecl (exp));
9223           return;
9224         }
9225       else if (tree_int_cst_lt (src, size))
9226         return;
9227     }
9228   else if (! tree_fits_uhwi_p (len) || ! tree_int_cst_lt (size, len))
9229     return;
9230
9231   warning_at (loc, 0, "%Kcall to %D will always overflow destination buffer",
9232               exp, get_callee_fndecl (exp));
9233 }
9234
9235 /* Emit warning if a buffer overflow is detected at compile time
9236    in __sprintf_chk/__vsprintf_chk calls.  */
9237
9238 static void
9239 maybe_emit_sprintf_chk_warning (tree exp, enum built_in_function fcode)
9240 {
9241   tree size, len, fmt;
9242   const char *fmt_str;
9243   int nargs = call_expr_nargs (exp);
9244
9245   /* Verify the required arguments in the original call.  */
9246
9247   if (nargs < 4)
9248     return;
9249   size = CALL_EXPR_ARG (exp, 2);
9250   fmt = CALL_EXPR_ARG (exp, 3);
9251
9252   if (! tree_fits_uhwi_p (size) || integer_all_onesp (size))
9253     return;
9254
9255   /* Check whether the format is a literal string constant.  */
9256   fmt_str = c_getstr (fmt);
9257   if (fmt_str == NULL)
9258     return;
9259
9260   if (!init_target_chars ())
9261     return;
9262
9263   /* If the format doesn't contain % args or %%, we know its size.  */
9264   if (strchr (fmt_str, target_percent) == 0)
9265     len = build_int_cstu (size_type_node, strlen (fmt_str));
9266   /* If the format is "%s" and first ... argument is a string literal,
9267      we know it too.  */
9268   else if (fcode == BUILT_IN_SPRINTF_CHK
9269            && strcmp (fmt_str, target_percent_s) == 0)
9270     {
9271       tree arg;
9272
9273       if (nargs < 5)
9274         return;
9275       arg = CALL_EXPR_ARG (exp, 4);
9276       if (! POINTER_TYPE_P (TREE_TYPE (arg)))
9277         return;
9278
9279       len = c_strlen (arg, 1);
9280       if (!len || ! tree_fits_uhwi_p (len))
9281         return;
9282     }
9283   else
9284     return;
9285
9286   if (! tree_int_cst_lt (len, size))
9287     warning_at (tree_nonartificial_location (exp),
9288                 0, "%Kcall to %D will always overflow destination buffer",
9289                 exp, get_callee_fndecl (exp));
9290 }
9291
9292 /* Emit warning if a free is called with address of a variable.  */
9293
9294 static void
9295 maybe_emit_free_warning (tree exp)
9296 {
9297   tree arg = CALL_EXPR_ARG (exp, 0);
9298
9299   STRIP_NOPS (arg);
9300   if (TREE_CODE (arg) != ADDR_EXPR)
9301     return;
9302
9303   arg = get_base_address (TREE_OPERAND (arg, 0));
9304   if (arg == NULL || INDIRECT_REF_P (arg) || TREE_CODE (arg) == MEM_REF)
9305     return;
9306
9307   if (SSA_VAR_P (arg))
9308     warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
9309                 "%Kattempt to free a non-heap object %qD", exp, arg);
9310   else
9311     warning_at (tree_nonartificial_location (exp), OPT_Wfree_nonheap_object,
9312                 "%Kattempt to free a non-heap object", exp);
9313 }
9314
9315 /* Fold a call to __builtin_object_size with arguments PTR and OST,
9316    if possible.  */
9317
9318 static tree
9319 fold_builtin_object_size (tree ptr, tree ost)
9320 {
9321   unsigned HOST_WIDE_INT bytes;
9322   int object_size_type;
9323
9324   if (!validate_arg (ptr, POINTER_TYPE)
9325       || !validate_arg (ost, INTEGER_TYPE))
9326     return NULL_TREE;
9327
9328   STRIP_NOPS (ost);
9329
9330   if (TREE_CODE (ost) != INTEGER_CST
9331       || tree_int_cst_sgn (ost) < 0
9332       || compare_tree_int (ost, 3) > 0)
9333     return NULL_TREE;
9334
9335   object_size_type = tree_to_shwi (ost);
9336
9337   /* __builtin_object_size doesn't evaluate side-effects in its arguments;
9338      if there are any side-effects, it returns (size_t) -1 for types 0 and 1
9339      and (size_t) 0 for types 2 and 3.  */
9340   if (TREE_SIDE_EFFECTS (ptr))
9341     return build_int_cst_type (size_type_node, object_size_type < 2 ? -1 : 0);
9342
9343   if (TREE_CODE (ptr) == ADDR_EXPR)
9344     {
9345       bytes = compute_builtin_object_size (ptr, object_size_type);
9346       if (wi::fits_to_tree_p (bytes, size_type_node))
9347         return build_int_cstu (size_type_node, bytes);
9348     }
9349   else if (TREE_CODE (ptr) == SSA_NAME)
9350     {
9351       /* If object size is not known yet, delay folding until
9352        later.  Maybe subsequent passes will help determining
9353        it.  */
9354       bytes = compute_builtin_object_size (ptr, object_size_type);
9355       if (bytes != (unsigned HOST_WIDE_INT) (object_size_type < 2 ? -1 : 0)
9356           && wi::fits_to_tree_p (bytes, size_type_node))
9357         return build_int_cstu (size_type_node, bytes);
9358     }
9359
9360   return NULL_TREE;
9361 }
9362
9363 /* Builtins with folding operations that operate on "..." arguments
9364    need special handling; we need to store the arguments in a convenient
9365    data structure before attempting any folding.  Fortunately there are
9366    only a few builtins that fall into this category.  FNDECL is the
9367    function, EXP is the CALL_EXPR for the call.  */
9368
9369 static tree
9370 fold_builtin_varargs (location_t loc, tree fndecl, tree *args, int nargs)
9371 {
9372   enum built_in_function fcode = DECL_FUNCTION_CODE (fndecl);
9373   tree ret = NULL_TREE;
9374
9375   switch (fcode)
9376     {
9377     case BUILT_IN_FPCLASSIFY:
9378       ret = fold_builtin_fpclassify (loc, args, nargs);
9379       break;
9380
9381     default:
9382       break;
9383     }
9384   if (ret)
9385     {
9386       ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
9387       SET_EXPR_LOCATION (ret, loc);
9388       TREE_NO_WARNING (ret) = 1;
9389       return ret;
9390     }
9391   return NULL_TREE;
9392 }
9393
9394 /* Initialize format string characters in the target charset.  */
9395
9396 bool
9397 init_target_chars (void)
9398 {
9399   static bool init;
9400   if (!init)
9401     {
9402       target_newline = lang_hooks.to_target_charset ('\n');
9403       target_percent = lang_hooks.to_target_charset ('%');
9404       target_c = lang_hooks.to_target_charset ('c');
9405       target_s = lang_hooks.to_target_charset ('s');
9406       if (target_newline == 0 || target_percent == 0 || target_c == 0
9407           || target_s == 0)
9408         return false;
9409
9410       target_percent_c[0] = target_percent;
9411       target_percent_c[1] = target_c;
9412       target_percent_c[2] = '\0';
9413
9414       target_percent_s[0] = target_percent;
9415       target_percent_s[1] = target_s;
9416       target_percent_s[2] = '\0';
9417
9418       target_percent_s_newline[0] = target_percent;
9419       target_percent_s_newline[1] = target_s;
9420       target_percent_s_newline[2] = target_newline;
9421       target_percent_s_newline[3] = '\0';
9422
9423       init = true;
9424     }
9425   return true;
9426 }
9427
9428 /* Helper function for do_mpfr_arg*().  Ensure M is a normal number
9429    and no overflow/underflow occurred.  INEXACT is true if M was not
9430    exactly calculated.  TYPE is the tree type for the result.  This
9431    function assumes that you cleared the MPFR flags and then
9432    calculated M to see if anything subsequently set a flag prior to
9433    entering this function.  Return NULL_TREE if any checks fail.  */
9434
9435 static tree
9436 do_mpfr_ckconv (mpfr_srcptr m, tree type, int inexact)
9437 {
9438   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
9439      overflow/underflow occurred.  If -frounding-math, proceed iff the
9440      result of calling FUNC was exact.  */
9441   if (mpfr_number_p (m) && !mpfr_overflow_p () && !mpfr_underflow_p ()
9442       && (!flag_rounding_math || !inexact))
9443     {
9444       REAL_VALUE_TYPE rr;
9445
9446       real_from_mpfr (&rr, m, type, GMP_RNDN);
9447       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR value,
9448          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
9449          but the mpft_t is not, then we underflowed in the
9450          conversion.  */
9451       if (real_isfinite (&rr)
9452           && (rr.cl == rvc_zero) == (mpfr_zero_p (m) != 0))
9453         {
9454           REAL_VALUE_TYPE rmode;
9455
9456           real_convert (&rmode, TYPE_MODE (type), &rr);
9457           /* Proceed iff the specified mode can hold the value.  */
9458           if (real_identical (&rmode, &rr))
9459             return build_real (type, rmode);
9460         }
9461     }
9462   return NULL_TREE;
9463 }
9464
9465 /* Helper function for do_mpc_arg*().  Ensure M is a normal complex
9466    number and no overflow/underflow occurred.  INEXACT is true if M
9467    was not exactly calculated.  TYPE is the tree type for the result.
9468    This function assumes that you cleared the MPFR flags and then
9469    calculated M to see if anything subsequently set a flag prior to
9470    entering this function.  Return NULL_TREE if any checks fail, if
9471    FORCE_CONVERT is true, then bypass the checks.  */
9472
9473 static tree
9474 do_mpc_ckconv (mpc_srcptr m, tree type, int inexact, int force_convert)
9475 {
9476   /* Proceed iff we get a normal number, i.e. not NaN or Inf and no
9477      overflow/underflow occurred.  If -frounding-math, proceed iff the
9478      result of calling FUNC was exact.  */
9479   if (force_convert
9480       || (mpfr_number_p (mpc_realref (m)) && mpfr_number_p (mpc_imagref (m))
9481           && !mpfr_overflow_p () && !mpfr_underflow_p ()
9482           && (!flag_rounding_math || !inexact)))
9483     {
9484       REAL_VALUE_TYPE re, im;
9485
9486       real_from_mpfr (&re, mpc_realref (m), TREE_TYPE (type), GMP_RNDN);
9487       real_from_mpfr (&im, mpc_imagref (m), TREE_TYPE (type), GMP_RNDN);
9488       /* Proceed iff GCC's REAL_VALUE_TYPE can hold the MPFR values,
9489          check for overflow/underflow.  If the REAL_VALUE_TYPE is zero
9490          but the mpft_t is not, then we underflowed in the
9491          conversion.  */
9492       if (force_convert
9493           || (real_isfinite (&re) && real_isfinite (&im)
9494               && (re.cl == rvc_zero) == (mpfr_zero_p (mpc_realref (m)) != 0)
9495               && (im.cl == rvc_zero) == (mpfr_zero_p (mpc_imagref (m)) != 0)))
9496         {
9497           REAL_VALUE_TYPE re_mode, im_mode;
9498
9499           real_convert (&re_mode, TYPE_MODE (TREE_TYPE (type)), &re);
9500           real_convert (&im_mode, TYPE_MODE (TREE_TYPE (type)), &im);
9501           /* Proceed iff the specified mode can hold the value.  */
9502           if (force_convert
9503               || (real_identical (&re_mode, &re)
9504                   && real_identical (&im_mode, &im)))
9505             return build_complex (type, build_real (TREE_TYPE (type), re_mode),
9506                                   build_real (TREE_TYPE (type), im_mode));
9507         }
9508     }
9509   return NULL_TREE;
9510 }
9511
9512 /* If arguments ARG0 and ARG1 are REAL_CSTs, call mpfr_remquo() to set
9513    the pointer *(ARG_QUO) and return the result.  The type is taken
9514    from the type of ARG0 and is used for setting the precision of the
9515    calculation and results.  */
9516
9517 static tree
9518 do_mpfr_remquo (tree arg0, tree arg1, tree arg_quo)
9519 {
9520   tree const type = TREE_TYPE (arg0);
9521   tree result = NULL_TREE;
9522
9523   STRIP_NOPS (arg0);
9524   STRIP_NOPS (arg1);
9525
9526   /* To proceed, MPFR must exactly represent the target floating point
9527      format, which only happens when the target base equals two.  */
9528   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
9529       && TREE_CODE (arg0) == REAL_CST && !TREE_OVERFLOW (arg0)
9530       && TREE_CODE (arg1) == REAL_CST && !TREE_OVERFLOW (arg1))
9531     {
9532       const REAL_VALUE_TYPE *const ra0 = TREE_REAL_CST_PTR (arg0);
9533       const REAL_VALUE_TYPE *const ra1 = TREE_REAL_CST_PTR (arg1);
9534
9535       if (real_isfinite (ra0) && real_isfinite (ra1))
9536         {
9537           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
9538           const int prec = fmt->p;
9539           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
9540           tree result_rem;
9541           long integer_quo;
9542           mpfr_t m0, m1;
9543
9544           mpfr_inits2 (prec, m0, m1, NULL);
9545           mpfr_from_real (m0, ra0, GMP_RNDN);
9546           mpfr_from_real (m1, ra1, GMP_RNDN);
9547           mpfr_clear_flags ();
9548           mpfr_remquo (m0, &integer_quo, m0, m1, rnd);
9549           /* Remquo is independent of the rounding mode, so pass
9550              inexact=0 to do_mpfr_ckconv().  */
9551           result_rem = do_mpfr_ckconv (m0, type, /*inexact=*/ 0);
9552           mpfr_clears (m0, m1, NULL);
9553           if (result_rem)
9554             {
9555               /* MPFR calculates quo in the host's long so it may
9556                  return more bits in quo than the target int can hold
9557                  if sizeof(host long) > sizeof(target int).  This can
9558                  happen even for native compilers in LP64 mode.  In
9559                  these cases, modulo the quo value with the largest
9560                  number that the target int can hold while leaving one
9561                  bit for the sign.  */
9562               if (sizeof (integer_quo) * CHAR_BIT > INT_TYPE_SIZE)
9563                 integer_quo %= (long)(1UL << (INT_TYPE_SIZE - 1));
9564
9565               /* Dereference the quo pointer argument.  */
9566               arg_quo = build_fold_indirect_ref (arg_quo);
9567               /* Proceed iff a valid pointer type was passed in.  */
9568               if (TYPE_MAIN_VARIANT (TREE_TYPE (arg_quo)) == integer_type_node)
9569                 {
9570                   /* Set the value. */
9571                   tree result_quo
9572                     = fold_build2 (MODIFY_EXPR, TREE_TYPE (arg_quo), arg_quo,
9573                                    build_int_cst (TREE_TYPE (arg_quo),
9574                                                   integer_quo));
9575                   TREE_SIDE_EFFECTS (result_quo) = 1;
9576                   /* Combine the quo assignment with the rem.  */
9577                   result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
9578                                                     result_quo, result_rem));
9579                 }
9580             }
9581         }
9582     }
9583   return result;
9584 }
9585
9586 /* If ARG is a REAL_CST, call mpfr_lgamma() on it and return the
9587    resulting value as a tree with type TYPE.  The mpfr precision is
9588    set to the precision of TYPE.  We assume that this mpfr function
9589    returns zero if the result could be calculated exactly within the
9590    requested precision.  In addition, the integer pointer represented
9591    by ARG_SG will be dereferenced and set to the appropriate signgam
9592    (-1,1) value.  */
9593
9594 static tree
9595 do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
9596 {
9597   tree result = NULL_TREE;
9598
9599   STRIP_NOPS (arg);
9600
9601   /* To proceed, MPFR must exactly represent the target floating point
9602      format, which only happens when the target base equals two.  Also
9603      verify ARG is a constant and that ARG_SG is an int pointer.  */
9604   if (REAL_MODE_FORMAT (TYPE_MODE (type))->b == 2
9605       && TREE_CODE (arg) == REAL_CST && !TREE_OVERFLOW (arg)
9606       && TREE_CODE (TREE_TYPE (arg_sg)) == POINTER_TYPE
9607       && TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (arg_sg))) == integer_type_node)
9608     {
9609       const REAL_VALUE_TYPE *const ra = TREE_REAL_CST_PTR (arg);
9610
9611       /* In addition to NaN and Inf, the argument cannot be zero or a
9612          negative integer.  */
9613       if (real_isfinite (ra)
9614           && ra->cl != rvc_zero
9615           && !(real_isneg (ra) && real_isinteger (ra, TYPE_MODE (type))))
9616         {
9617           const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
9618           const int prec = fmt->p;
9619           const mp_rnd_t rnd = fmt->round_towards_zero? GMP_RNDZ : GMP_RNDN;
9620           int inexact, sg;
9621           mpfr_t m;
9622           tree result_lg;
9623
9624           mpfr_init2 (m, prec);
9625           mpfr_from_real (m, ra, GMP_RNDN);
9626           mpfr_clear_flags ();
9627           inexact = mpfr_lgamma (m, &sg, m, rnd);
9628           result_lg = do_mpfr_ckconv (m, type, inexact);
9629           mpfr_clear (m);
9630           if (result_lg)
9631             {
9632               tree result_sg;
9633
9634               /* Dereference the arg_sg pointer argument.  */
9635               arg_sg = build_fold_indirect_ref (arg_sg);
9636               /* Assign the signgam value into *arg_sg. */
9637               result_sg = fold_build2 (MODIFY_EXPR,
9638                                        TREE_TYPE (arg_sg), arg_sg,
9639                                        build_int_cst (TREE_TYPE (arg_sg), sg));
9640               TREE_SIDE_EFFECTS (result_sg) = 1;
9641               /* Combine the signgam assignment with the lgamma result.  */
9642               result = non_lvalue (fold_build2 (COMPOUND_EXPR, type,
9643                                                 result_sg, result_lg));
9644             }
9645         }
9646     }
9647
9648   return result;
9649 }
9650
9651 /* If arguments ARG0 and ARG1 are a COMPLEX_CST, call the two-argument
9652    mpc function FUNC on it and return the resulting value as a tree
9653    with type TYPE.  The mpfr precision is set to the precision of
9654    TYPE.  We assume that function FUNC returns zero if the result
9655    could be calculated exactly within the requested precision.  If
9656    DO_NONFINITE is true, then fold expressions containing Inf or NaN
9657    in the arguments and/or results.  */
9658
9659 tree
9660 do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite,
9661              int (*func)(mpc_ptr, mpc_srcptr, mpc_srcptr, mpc_rnd_t))
9662 {
9663   tree result = NULL_TREE;
9664
9665   STRIP_NOPS (arg0);
9666   STRIP_NOPS (arg1);
9667
9668   /* To proceed, MPFR must exactly represent the target floating point
9669      format, which only happens when the target base equals two.  */
9670   if (TREE_CODE (arg0) == COMPLEX_CST && !TREE_OVERFLOW (arg0)
9671       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg0))) == REAL_TYPE
9672       && TREE_CODE (arg1) == COMPLEX_CST && !TREE_OVERFLOW (arg1)
9673       && TREE_CODE (TREE_TYPE (TREE_TYPE (arg1))) == REAL_TYPE
9674       && REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0))))->b == 2)
9675     {
9676       const REAL_VALUE_TYPE *const re0 = TREE_REAL_CST_PTR (TREE_REALPART (arg0));
9677       const REAL_VALUE_TYPE *const im0 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg0));
9678       const REAL_VALUE_TYPE *const re1 = TREE_REAL_CST_PTR (TREE_REALPART (arg1));
9679       const REAL_VALUE_TYPE *const im1 = TREE_REAL_CST_PTR (TREE_IMAGPART (arg1));
9680
9681       if (do_nonfinite
9682           || (real_isfinite (re0) && real_isfinite (im0)
9683               && real_isfinite (re1) && real_isfinite (im1)))
9684         {
9685           const struct real_format *const fmt =
9686             REAL_MODE_FORMAT (TYPE_MODE (TREE_TYPE (type)));
9687           const int prec = fmt->p;
9688           const mp_rnd_t rnd = fmt->round_towards_zero ? GMP_RNDZ : GMP_RNDN;
9689           const mpc_rnd_t crnd = fmt->round_towards_zero ? MPC_RNDZZ : MPC_RNDNN;
9690           int inexact;
9691           mpc_t m0, m1;
9692
9693           mpc_init2 (m0, prec);
9694           mpc_init2 (m1, prec);
9695           mpfr_from_real (mpc_realref (m0), re0, rnd);
9696           mpfr_from_real (mpc_imagref (m0), im0, rnd);
9697           mpfr_from_real (mpc_realref (m1), re1, rnd);
9698           mpfr_from_real (mpc_imagref (m1), im1, rnd);
9699           mpfr_clear_flags ();
9700           inexact = func (m0, m0, m1, crnd);
9701           result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
9702           mpc_clear (m0);
9703           mpc_clear (m1);
9704         }
9705     }
9706
9707   return result;
9708 }
9709
9710 /* A wrapper function for builtin folding that prevents warnings for
9711    "statement without effect" and the like, caused by removing the
9712    call node earlier than the warning is generated.  */
9713
9714 tree
9715 fold_call_stmt (gcall *stmt, bool ignore)
9716 {
9717   tree ret = NULL_TREE;
9718   tree fndecl = gimple_call_fndecl (stmt);
9719   location_t loc = gimple_location (stmt);
9720   if (fndecl
9721       && TREE_CODE (fndecl) == FUNCTION_DECL
9722       && DECL_BUILT_IN (fndecl)
9723       && !gimple_call_va_arg_pack_p (stmt))
9724     {
9725       int nargs = gimple_call_num_args (stmt);
9726       tree *args = (nargs > 0
9727                     ? gimple_call_arg_ptr (stmt, 0)
9728                     : &error_mark_node);
9729
9730       if (avoid_folding_inline_builtin (fndecl))
9731         return NULL_TREE;
9732       if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
9733         {
9734           return targetm.fold_builtin (fndecl, nargs, args, ignore);
9735         }
9736       else
9737         {
9738           ret = fold_builtin_n (loc, fndecl, args, nargs, ignore);
9739           if (ret)
9740             {
9741               /* Propagate location information from original call to
9742                  expansion of builtin.  Otherwise things like
9743                  maybe_emit_chk_warning, that operate on the expansion
9744                  of a builtin, will use the wrong location information.  */
9745               if (gimple_has_location (stmt))
9746                 {
9747                   tree realret = ret;
9748                   if (TREE_CODE (ret) == NOP_EXPR)
9749                     realret = TREE_OPERAND (ret, 0);
9750                   if (CAN_HAVE_LOCATION_P (realret)
9751                       && !EXPR_HAS_LOCATION (realret))
9752                     SET_EXPR_LOCATION (realret, loc);
9753                   return realret;
9754                 }
9755               return ret;
9756             }
9757         }
9758     }
9759   return NULL_TREE;
9760 }
9761
9762 /* Look up the function in builtin_decl that corresponds to DECL
9763    and set ASMSPEC as its user assembler name.  DECL must be a
9764    function decl that declares a builtin.  */
9765
9766 void
9767 set_builtin_user_assembler_name (tree decl, const char *asmspec)
9768 {
9769   tree builtin;
9770   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
9771               && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
9772               && asmspec != 0);
9773
9774   builtin = builtin_decl_explicit (DECL_FUNCTION_CODE (decl));
9775   set_user_assembler_name (builtin, asmspec);
9776   switch (DECL_FUNCTION_CODE (decl))
9777     {
9778     case BUILT_IN_MEMCPY:
9779       init_block_move_fn (asmspec);
9780       memcpy_libfunc = set_user_assembler_libfunc ("memcpy", asmspec);
9781       break;
9782     case BUILT_IN_MEMSET:
9783       init_block_clear_fn (asmspec);
9784       memset_libfunc = set_user_assembler_libfunc ("memset", asmspec);
9785       break;
9786     case BUILT_IN_MEMMOVE:
9787       memmove_libfunc = set_user_assembler_libfunc ("memmove", asmspec);
9788       break;
9789     case BUILT_IN_MEMCMP:
9790       memcmp_libfunc = set_user_assembler_libfunc ("memcmp", asmspec);
9791       break;
9792     case BUILT_IN_ABORT:
9793       abort_libfunc = set_user_assembler_libfunc ("abort", asmspec);
9794       break;
9795     case BUILT_IN_FFS:
9796       if (INT_TYPE_SIZE < BITS_PER_WORD)
9797         {
9798           set_user_assembler_libfunc ("ffs", asmspec);
9799           set_optab_libfunc (ffs_optab, mode_for_size (INT_TYPE_SIZE,
9800                                                        MODE_INT, 0), "ffs");
9801         }
9802       break;
9803     default:
9804       break;
9805     }
9806 }
9807
9808 /* Return true if DECL is a builtin that expands to a constant or similarly
9809    simple code.  */
9810 bool
9811 is_simple_builtin (tree decl)
9812 {
9813   if (decl && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
9814     switch (DECL_FUNCTION_CODE (decl))
9815       {
9816         /* Builtins that expand to constants.  */
9817       case BUILT_IN_CONSTANT_P:
9818       case BUILT_IN_EXPECT:
9819       case BUILT_IN_OBJECT_SIZE:
9820       case BUILT_IN_UNREACHABLE:
9821         /* Simple register moves or loads from stack.  */
9822       case BUILT_IN_ASSUME_ALIGNED:
9823       case BUILT_IN_RETURN_ADDRESS:
9824       case BUILT_IN_EXTRACT_RETURN_ADDR:
9825       case BUILT_IN_FROB_RETURN_ADDR:
9826       case BUILT_IN_RETURN:
9827       case BUILT_IN_AGGREGATE_INCOMING_ADDRESS:
9828       case BUILT_IN_FRAME_ADDRESS:
9829       case BUILT_IN_VA_END:
9830       case BUILT_IN_STACK_SAVE:
9831       case BUILT_IN_STACK_RESTORE:
9832         /* Exception state returns or moves registers around.  */
9833       case BUILT_IN_EH_FILTER:
9834       case BUILT_IN_EH_POINTER:
9835       case BUILT_IN_EH_COPY_VALUES:
9836         return true;
9837
9838       default:
9839         return false;
9840       }
9841
9842   return false;
9843 }
9844
9845 /* Return true if DECL is a builtin that is not expensive, i.e., they are
9846    most probably expanded inline into reasonably simple code.  This is a
9847    superset of is_simple_builtin.  */
9848 bool
9849 is_inexpensive_builtin (tree decl)
9850 {
9851   if (!decl)
9852     return false;
9853   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_MD)
9854     return true;
9855   else if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL)
9856     switch (DECL_FUNCTION_CODE (decl))
9857       {
9858       case BUILT_IN_ABS:
9859       case BUILT_IN_ALLOCA:
9860       case BUILT_IN_ALLOCA_WITH_ALIGN:
9861       case BUILT_IN_BSWAP16:
9862       case BUILT_IN_BSWAP32:
9863       case BUILT_IN_BSWAP64:
9864       case BUILT_IN_CLZ:
9865       case BUILT_IN_CLZIMAX:
9866       case BUILT_IN_CLZL:
9867       case BUILT_IN_CLZLL:
9868       case BUILT_IN_CTZ:
9869       case BUILT_IN_CTZIMAX:
9870       case BUILT_IN_CTZL:
9871       case BUILT_IN_CTZLL:
9872       case BUILT_IN_FFS:
9873       case BUILT_IN_FFSIMAX:
9874       case BUILT_IN_FFSL:
9875       case BUILT_IN_FFSLL:
9876       case BUILT_IN_IMAXABS:
9877       case BUILT_IN_FINITE:
9878       case BUILT_IN_FINITEF:
9879       case BUILT_IN_FINITEL:
9880       case BUILT_IN_FINITED32:
9881       case BUILT_IN_FINITED64:
9882       case BUILT_IN_FINITED128:
9883       case BUILT_IN_FPCLASSIFY:
9884       case BUILT_IN_ISFINITE:
9885       case BUILT_IN_ISINF_SIGN:
9886       case BUILT_IN_ISINF:
9887       case BUILT_IN_ISINFF:
9888       case BUILT_IN_ISINFL:
9889       case BUILT_IN_ISINFD32:
9890       case BUILT_IN_ISINFD64:
9891       case BUILT_IN_ISINFD128:
9892       case BUILT_IN_ISNAN:
9893       case BUILT_IN_ISNANF:
9894       case BUILT_IN_ISNANL:
9895       case BUILT_IN_ISNAND32:
9896       case BUILT_IN_ISNAND64:
9897       case BUILT_IN_ISNAND128:
9898       case BUILT_IN_ISNORMAL:
9899       case BUILT_IN_ISGREATER:
9900       case BUILT_IN_ISGREATEREQUAL:
9901       case BUILT_IN_ISLESS:
9902       case BUILT_IN_ISLESSEQUAL:
9903       case BUILT_IN_ISLESSGREATER:
9904       case BUILT_IN_ISUNORDERED:
9905       case BUILT_IN_VA_ARG_PACK:
9906       case BUILT_IN_VA_ARG_PACK_LEN:
9907       case BUILT_IN_VA_COPY:
9908       case BUILT_IN_TRAP:
9909       case BUILT_IN_SAVEREGS:
9910       case BUILT_IN_POPCOUNTL:
9911       case BUILT_IN_POPCOUNTLL:
9912       case BUILT_IN_POPCOUNTIMAX:
9913       case BUILT_IN_POPCOUNT:
9914       case BUILT_IN_PARITYL:
9915       case BUILT_IN_PARITYLL:
9916       case BUILT_IN_PARITYIMAX:
9917       case BUILT_IN_PARITY:
9918       case BUILT_IN_LABS:
9919       case BUILT_IN_LLABS:
9920       case BUILT_IN_PREFETCH:
9921       case BUILT_IN_ACC_ON_DEVICE:
9922         return true;
9923
9924       default:
9925         return is_simple_builtin (decl);
9926       }
9927
9928   return false;
9929 }