gcc/builtins.c

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