gcc/builtins.c

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